Autobahn Python

Warnings

• breaking Autobahn Python has dropped support for older Python versions. As of version 25.12.2, it officially requires Python >=3.11. Older versions supported Python 3.7+ (since v21.2.1) and Python 2 up to v19.11.2.
  Fix: Ensure your project is running on Python 3.11 or newer.
• gotcha When using asyncio in child threads or subprocesses (e.g., with `multiprocessing`), you must explicitly create and set a new event loop for each new thread/process on Unix-like systems. If you don't, you'll encounter `AssertionError: There is no current event loop in thread '...'`.
  Fix: Use `loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop)` at the beginning of the child thread/process execution.
• gotcha WAMP clients (both Python and JavaScript) require a WAMP router (e.g., Crossbar.io) to mediate communication. Autobahn provides the client/component library, but not the router itself. WAMP servers should also explicitly set the realm they intend to join.
  Fix: Run a WAMP router (like Crossbar.io) separately and ensure your WAMP components are configured to connect to it and join the correct realm.
• deprecated The `autobahn.util.time_ns` helper was deprecated in favor of `txaio.time_ns` in version 20.1.3.
  Fix: Replace `from autobahn.util import time_ns` with `from txaio import time_ns`.
• deprecated The `accelerate` install variant is no longer recommended. Autobahn now includes NVX (Native Vector Extensions) for SIMD-accelerated WebSocket operations (XOR masking and UTF-8 validation), which leverages CFFI for performance.
  Fix: Remove `accelerate` from your install variants. NVX is often included in platform-specific binary wheels.

Install

• pip install autobahn Minimal install
• pip install autobahn[all] Full install (includes Twisted, asyncio, encryption, and optional dependencies)
• pip install autobahn[asyncio,encryption] Common asyncio-based install with TLS
• pip install autobahn[twisted,encryption] Common Twisted-based install with TLS

Imports

• WebSocketServerProtocol

  from autobahn.asyncio.websocket import WebSocketServerProtocol
  # or: from autobahn.twisted.websocket import WebSocketServerProtocol

• WebSocketClientProtocol

  from autobahn.asyncio.websocket import WebSocketClientProtocol
  # or: from autobahn.twisted.websocket import WebSocketClientProtocol

• WebSocketServerFactory

  from autobahn.asyncio.websocket import WebSocketServerFactory
  # or: from autobahn.twisted.websocket import WebSocketServerFactory

• ApplicationSession

  from autobahn.asyncio.wamp import ApplicationSession
  # or: from autobahn.twisted.wamp import ApplicationSession

• Component

  from autobahn.wamp.component import Component

  Use Component with run() function instead of older ApplicationRunner which lacks features.

Quickstart

This quickstart demonstrates a basic WebSocket echo server using the `asyncio` backend. It listens on `ws://127.0.0.1:9000` and echoes back any message it receives. This example can be run directly. For WAMP applications, a separate WAMP Router like Crossbar.io is required.

import asyncio
from autobahn.asyncio.websocket import WebSocketServerFactory, WebSocketServerProtocol

class MyServerProtocol(WebSocketServerProtocol):
    def onConnect(self, request):
        print(f"Client connecting: {request.peer}")

    def onOpen(self):
        print("WebSocket connection open.")

    def onMessage(self, payload, isBinary):
        if isBinary:
            print(f"Binary message received: {len(payload)} bytes")
        else:
            print(f"Text message received: {payload.decode('utf8')}")

        # echo back message verbatim
        self.sendMessage(payload, isBinary)

    def onClose(self, wasClean, code, reason):
        print(f"WebSocket connection closed: {reason} (code={code}, clean={wasClean})")

async def main():
    factory = WebSocketServerFactory("ws://127.0.0.1:9000")
    factory.protocol = MyServerProtocol

    server = await asyncio.get_event_loop().create_server(factory, '127.0.0.1', 9000)
    print("WebSocket server started on ws://127.0.0.1:9000")

    try:
        await server.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        server.close()
        await server.wait_closed()
        asyncio.get_event_loop().close()

if __name__ == '__main__':
    asyncio.run(main())