Autobahn|Python Reference

Release v0.8.6. (Changelog)

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

in Python 2 and 3, running on Twisted and asyncio.

WebSocket allows bidirectional real-time messaging on the Web and WAMP adds asynchronous Remote Procedure Calls and Publish & Subscribe on top of WebSocket.

WAMP is ideal for distributed, multi-client and server applications, such as multi-user database-drive business applications, sensor networks (IoT), instant messaging or MMOGs (massively multi-player online games) .

WAMP enables application architectures with application code distributed freely across processes and devices according to functional aspects. Since WAMP implementations exist for multiple languages, WAMP applications can be polyglott. Application components can be implemented in a language and run on a device which best fit the particular use case.

Show me some code

Using Autobahn|Python you can create both clients and servers in Python speaking just plain WebSocket or WAMP.


A sample WebSocket server:

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))

Complete example code:


A sample WAMP application component:

class MyComponent(ApplicationSession):

   def onConnect(self):

   def onJoin(self, details):

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

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

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

      # 3) register a procedure for remoting
      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))


  • WAMP application components can be run in servers and clients without any modification to your component class.
  • While Autobahn|Python supports both Twisted and asyncio for WebSocket code, WAMP is currently only supported on Twisted.
  • AutobahnJS allows you to write WAMP application components in JavaScript which run in browsers and Nodejs. Here is how above example looks like in JavaScript.


Python support

Support for Autobahn|Python on Twisted and asyncio is as follows:

Python Twisted asyncio Notes
CPython 2.6 yes yes asyncio support via trollius
CPython 2.7 yes yes asyncio support via trollius
CPython 3.3 yes yes asyncio support via tulip
CPython 3.4+ yes yes asyncio in the standard library
PyPy 2.2+ yes yes asyncio support via trollius
Jython 2.7+ yes ? Issues: 1, 2

WebSocket - implemented on both Twisted and asyncio

WAMP - currently only implented on Twisted

Where to go from here

Overview of Examples lists code examples covering a broader range of uses cases and advanced WAMP features.

Programming with WebSocekt explains all you need to know about using Autobahn|Python as a WebSocket library, and includes a full reference for the relevant parts of the API.

Programming with WAMP gives an introduction for programming with WAMP (v2) in Python using Autobahn|Python.

API Reference contains the full API reference for both WebSocket and WAMP.


Autobahn|Python is a subproject of Autobahn and provides open-source implementations of The WebSocket Protocol and the The Web Application Messaging Protocol (WAMP) in Python running on Twisted and asyncio.

Useful Links

Stay Informed

Table Of Contents


Page Contents