var socket = eio('http://chat.example.com');
socket.on('open', function() { alert('connected'); });
socket.on('message', function(data) { alert(data); });
socket.on('close', function() { alert('disconnected'); });
socket.send('Hello from the client!');

import engineio
import eventlet
from flask import Flask, render_template
eio = engineio.Server()
app = Flask(__name__)
@app.route('/')
def index():
    """Serve the client-side application."""
    return render_template('index.html')
@eio.on('connect')
def connect(sid, environ):
    print("connect ", sid)
@eio.on('message')
def message(sid, data):
    print("message ", data)
    eio.send(sid, 'reply')
@eio.on('disconnect')
def disconnect(sid):
    print('disconnect ', sid)
if __name__ == '__main__':
    # wrap Flask application with engineio's middleware
    app = engineio.Middleware(eio, app)
    # deploy as an eventlet WSGI server
    eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

from aiohttp import web
import engineio
eio = engineio.AsyncServer()
app = web.Application()
# attach the Engine.IO server to the application
eio.attach(app)
async def index(request):
    """Serve the client-side application."""
    with open('index.html') as f:
        return web.Response(text=f.read(), content_type='text/html')
@eio.on('connect')
def connect(sid, environ):
    print("connect ", sid)
@eio.on('message')
async def message(sid, data):
    print("message ", data)
    await eio.send(sid, 'reply')
@eio.on('disconnect')
def disconnect(sid):
    print('disconnect ', sid)
app.router.add_static('/static', 'static')
app.router.add_get('/', index)
if __name__ == '__main__':
    # run the aiohttp application
    web.run_app(app)

eio = engineio.AsyncServer(async_mode='aiohttp')

app = web.Application()
eio.attach(app)

if __name__ == '__main__':
    web.run_app(app)

eio = engineio.AsyncServer(async_mode='tornado')

app = tornado.web.Application(
    [
        (r"/engine.io/", engineio.get_tornado_handler(eio)),
    ],
    # ... other application options
)

app.listen(port)
tornado.ioloop.IOLoop.current().start()

eio = engineio.AsyncServer(async_mode='sanic')

app = Sanic()
eio.attach(app)

if __name__ == '__main__':
    app.run()

eio = engineio.AsyncServer(async_mode='asgi')
app = engineio.ASGIApp(eio)

eio = engineio.Server(async_mode='eventlet')

app = engineio.Middleware(eio)
import eventlet
eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

$ gunicorn -k eventlet -w 1 module:app

# gevent alone or with gevent-websocket
eio = engineio.Server(async_mode='gevent')

from gevent import pywsgi
app = engineio.Middleware(eio)
pywsgi.WSGIServer(('', 8000), app).serve_forever()

from gevent import pywsgi
from geventwebsocket.handler import WebSocketHandler
app = engineio.Middleware(eio)
pywsgi.WSGIServer(('', 8000), app,
                  handler_class=WebSocketHandler).serve_forever()

$ gunicorn -k gevent -w 1 module:app

$ gunicorn -k geventwebsocket.gunicorn.workers.GeventWebSocketWorker -w 1 module: app

# gevent with uWSGI
eio = engineio.Server(async_mode='gevent_uwsgi')

$ uwsgi --http :5000 --gevent 1000 --http-websockets --master --wsgi-file latency.py --callable app

eio = engineio.Server(async_mode='threading')

eio = engineio.Server(async_mode='threading')
app = Flask(__name__)
app.wsgi_app = engineio.Middleware(eio, app.wsgi_app)
# ... Engine.IO and Flask handler functions ...
if __name__ == '__main__':
    app.run(threaded=True)

Parameters

disconnect(sid=None)

Disconnect a client.

handle_request(environ, start_response)

Handle an HTTP request from the client.

This is the entry point of the Engine.IO application, using the same interface as a WSGI application. For the typical usage, this function is invoked by the Middleware instance, but it can be invoked directly when the middleware is not used.

This function returns the HTTP response body to deliver to the client as a byte sequence.

on(event, handler=None)

Register an event handler.

Example usage:

# as a decorator:
@eio.on('connect')
def connect_handler(sid, environ):
    print('Connection request')
    if environ['REMOTE_ADDR'] in blacklisted:
        return False  # reject
# as a method:
def message_handler(sid, msg):
    print('Received message: ', msg)
    eio.send(sid, 'response')
eio.on('message', message_handler)

The handler function receives the sid (session ID) for the client as first argument. The 'connect' event handler receives the WSGI environment as a second argument, and can return False to reject the connection. The 'message' handler receives the message payload as a second argument. The 'disconnect' handler does not take a second argument.

send(sid, data, binary=None)

Send a message to a client.

sleep(seconds=0)

Sleep for the requested amount of time using the appropriate async model.

This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode.

start_background_task(target, *args, **kwargs)

Start a background task using the appropriate async model.

This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode.

This function returns an object compatible with the Thread class in the Python standard library. The start() method on this object is already called by this function.

transport(sid)

Return the name of the transport used by the client.

The two possible values returned by this function are 'polling' and 'websocket'.

Parameters

attach(app, engineio_path='engine.io')

Attach the Engine.IO server to an application.

disconnect(sid=None)

Disconnect a client.

Note: this method is a coroutine.

handle_request(*args, **kwargs)

Handle an HTTP request from the client.

This is the entry point of the Engine.IO application. This function returns the HTTP response to deliver to the client.

Note: this method is a coroutine.

on(event, handler=None)

Register an event handler.

Example usage:

# as a decorator:
@eio.on('connect')
def connect_handler(sid, environ):
    print('Connection request')
    if environ['REMOTE_ADDR'] in blacklisted:
        return False  # reject
# as a method:
def message_handler(sid, msg):
    print('Received message: ', msg)
    eio.send(sid, 'response')
eio.on('message', message_handler)

The handler function receives the sid (session ID) for the client as first argument. The 'connect' event handler receives the WSGI environment as a second argument, and can return False to reject the connection. The 'message' handler receives the message payload as a second argument. The 'disconnect' handler does not take a second argument.

send(sid, data, binary=None)

Send a message to a client.

Note: this method is a coroutine.

sleep(seconds=0)

Sleep for the requested amount of time using the appropriate async model.

This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode.

Note: this method is a coroutine.

start_background_task(target, *args, **kwargs)

Start a background task using the appropriate async model.

This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode.

The return value is a asyncio.Task object.

transport(sid)

Return the name of the transport used by the client.

The two possible values returned by this function are 'polling' and 'websocket'.

Parameters

Parameters