Autobahn Python

WebSocket and WAMP in Python for Twisted and asyncio
Alternatives To Autobahn Python
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Awesome Python Cn24,822
a year ago19otherMakefile
Autobahn Python2,4291,8131496 months ago155July 20, 2023182mitPython
WebSocket and WAMP in Python for Twisted and asyncio
Eliot1,0585220a month ago27October 30, 2023116apache-2.0Python
Eliot: the logging system that tells you *why* it happened
a year ago3December 23, 202145mitPython
sync/async MongoDB ODM, yes.
Requests Threads331
5 years ago7Python
🎭 Twisted Deferred Thread backend for Requests.
Pyee33033516510 days ago48November 23, 20233mitPython
A rough port of Node.js's EventEmitter to Python with a few tricks of its own
Arsenic2931a year ago12August 23, 202151otherPython
Async WebDriver implementation for asyncio and asyncio-compatible frameworks
Prometheus Async1515995 days ago16May 14, 20221apache-2.0Python
Async helpers for prometheus_client.
Scrapy Puppeteer103
2 years ago1November 30, 20188mitPython
Scrapy + Puppeteer
Txaio5796935a year ago38January 15, 202316mitPython
Utilities to support code that runs unmodified on Twisted and asyncio
Alternatives To Autobahn Python
Select To Compare

Alternative Project Comparisons


WebSocket & WAMP for Python on Twisted and asyncio.


Autobahn|Python is a subproject of Autobahn and provides open-source implementations of

for Python 3.7+ and running on Twisted and asyncio.

You can use Autobahn|Python to create clients and servers in Python speaking just plain WebSocket or WAMP.

WebSocket allows bidirectional real-time messaging on the Web and beyond, while WAMP adds real-time application communication on top of WebSocket.

WAMP provides asynchronous Remote Procedure Calls and Publish & Subscribe for applications in one protocol running over WebSocket. WAMP is a routed protocol, so you need a WAMP Router to connect your Autobahn|Python based clients. We provide, but there are other options as well.


Autobahn|Python up to version v19.11.2 supported Python 2 and 3.4+, and up to version v20.7.1 supported Python 3.5+, and up to version v21.2.1 supported Python 3.6+.


  • framework for WebSocket and WAMP clients and servers
  • runs on CPython and PyPy <>
  • runs under Twisted and asyncio - implements WebSocket RFC6455 and Draft Hybi-10+
  • implements WebSocket compression
  • implements WAMP, the Web Application Messaging Protocol
  • high-performance, fully asynchronous implementation
  • best-in-class standards conformance (100% strict passes with Autobahn Testsuite: Client Server)
  • message-, frame- and streaming-APIs for WebSocket
  • supports TLS (secure WebSocket) and proxies
  • Open-source (MIT license)

Show me some code

To give you a first impression, here are two examples. We have lot more in the repo.

WebSocket Echo Server

Here is a simple WebSocket Echo Server that will echo back any WebSocket message received:

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

class MyServerProtocol(WebSocketServerProtocol):

    def onConnect(self, request):
        print("Client connecting: {}".format(request.peer))

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

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

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

    def onClose(self, wasClean, code, reason):
        print("WebSocket connection closed: {}".format(reason))

To actually run above server protocol, you need some lines of boilerplate.

WAMP Application Component

Here is a WAMP Application Component that performs all four types of actions that WAMP provides:

  1. subscribe to a topic
  2. publish an event
  3. register a procedure
  4. call a procedure
from autobahn.twisted.wamp import ApplicationSession
# or: from autobahn.asyncio.wamp import ApplicationSession

class MyComponent(ApplicationSession):

    def onJoin(self, details):

        # 1. subscribe to a topic so we receive events
        def onevent(msg):
            print("Got event: {}".format(msg))

        yield self.subscribe(onevent, 'com.myapp.hello')

        # 2. publish an event to a topic
        self.publish('com.myapp.hello', 'Hello, world!')

        # 3. register a procedure for remote calling
        def add2(x, y):
            return x + y

        self.register(add2, 'com.myapp.add2')

        # 4. call a remote procedure
        res = yield'com.myapp.add2', 2, 3)
        print("Got result: {}".format(res))

Above code will work on Twisted and asyncio by changing a single line (the base class of MyComponent). To actually run above application component, you need some lines of boilerplate and a WAMP Router.


Networking framework

Autobahn runs on both Twisted and asyncio. To select the respective netoworking framework, install flavor:

  • asyncio: Install asyncio (when on Python 2, otherwise it's included in the standard library already) and asyncio support in Autobahn
  • twisted: Install Twisted and Twisted support in Autobahn

WebSocket acceleration and compression

  • accelerate: Install WebSocket acceleration - Only use on CPython - not on PyPy (which is faster natively)
  • compress: Install (non-standard) WebSocket compressors bzip2 and snappy (standard deflate based WebSocket compression is already included in the base install)

Encryption and WAMP authentication

Autobahn supports running over TLS (for WebSocket and all WAMP transports) as well as WAMP-cryposign authentication.

To install use this flavor:

  • encryption: Installs TLS and WAMP-cryptosign dependencies

Autobahn also supports WAMP-SCRAM authentication. To install:

  • scram: Installs WAMP-SCRAM dependencies


Autobahn includes support for XBR. To install use this flavor:

  • xbr:

To install:

pip install autobahn[xbr]

or (Twisted, with more bells an whistles)

pip install autobahn[twisted,encryption,serialization,xbr]

or (asyncio, with more bells an whistles)

pip install autobahn[asyncio,encryption,serialization,xbr]

Native vector extensions (NVX)

> This is NOT yet complete - ALPHA!

Autobahn contains NVX, a network accelerator library that provides SIMD accelerated native vector code for WebSocket (XOR masking) and UTF-8 validation.

WAMP Serializers

  • serialization: To install additional WAMP serializers: CBOR, MessagePack, UBJSON and Flatbuffers

Above is for advanced uses. In general we recommend to use CBOR where you can, and JSON (from the standard library) otherwise.

To install Autobahn with all available serializers:

pip install autobahn[serializers]

or (development install)

pip install -e .[serializers]

Further, to speed up JSON on CPython using ujson, set the environment variable:



Using ujson (on both CPython and PyPy) will break the ability of Autobahn to transport and translate binary application payloads in WAMP transparently. This ability depends on features of the regular JSON standard library module not available on ujson.

Popular Asyncio Projects
Popular Twisted Projects
Popular Control Flow Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Real Time