python-can: CAN Bus Streaming API [+ Demo Showcases]

Our CANsub.2 and CANsub.4 let you send/receive CAN/CAN FD data over USB or Ethernet in real-time. This is often relevant in automotive/industrial OEM development, reverse engineering and CAN bus diagnostics. The CANsub supports 20,000+ frames/sec, 1 µs timestamps, on-device transmit jobs with 10 µs edge-based timing, hardware filters and galvanic isolation.

If your goal is sensor streaming rather than CAN frame streaming, our CANmod devices can also be used via USB to stream GPS/temperature/analog sensor data in real-time, e.g. the CANmod.gps and CANmod.temp. Note that you can also use the CANmod.router as a CAN-USB interface, though the CANsub is superior for this purpose.

webCAN is our recommended software tool for most use cases. It runs on the CANsub, meaning you simply open the software via your browser - no installation required. Further, CANsub enables you to both configure the device, stream raw/decoded CAN data, create visual plots and more - i.e. all your basic streaming needs.

In contrast, using Python is more complex - but enables workflows beyond webCAN:

• Scripted receive/transmit workflows (e.g. for conditional/dynamic transmission)
• Integrations like MQTT or cloud forwarding for remote dashboards and alerting
• Simulation rigs that mimic ECU behaviour
• CI and test pipelines
• Integration with NumPy / pandas / Grafana via custom code
• Sending/receiving CAN data via your command line (e.g. for LLMs) via cantools

In short: Use webCAN for 'everyday streaming tasks' and python-can when you need scripted or programmatic control - or when CAN streaming has to be embedded inside a larger automated system.

Yes. The CANsub operates as a network device over both USB and Ethernet - not as a legacy COM-port device. Connecting via USB automatically creates a virtual network adapter (no drivers to install), and Ethernet exposes the same network interface. This makes the CANsub OS/platform agnostic and lets you reach one or many devices across a network.

Each device is addressable via a unique hostname - aabbccdd-usb.local over USB or aabbccdd-eth.local over Ethernet (where aabbccdd is the device-ID printed on the label). In python-can, every CAN channel then has its own URL-style endpoint built from this hostname plus a 1-based channel index, e.g. aabbccdd-usb.local@1 for channel 1. You open each channel as its own python-can bus, so you can run multiple channels - and multiple devices - in parallel.

You do not need to hardcode these endpoints. The python-can-cansub package supports mDNS discovery to auto-detect all connected CANsub devices / channels (across USB and Ethernet) and return ready-to-use configs that you pass in your script.

Every received and transmitted frame is timestamped by the CANsub itself at 1 µs resolution, sampled on the CAN bus edge (the frame's start-of-frame) rather than on your PC's clock. Timestamp accuracy therefore does not depend on client-side/host or network timing, which is critical for precise timing analysis and correlation.

The CANsub supports two transmit mechanisms, both available in python-can:

• Edge-based transmit sequences: Deployed as on-device 'jobs' (via bus.send_periodic()). The device generates the timing on the edge, giving very precise inter-message timing (down to 10 µs) that is independent of client/network latency. The sequence must follow the structural limits of these jobs (per the OpenAPI description), so they suit more static, periodic sequences - ideal when latency between device and client is a challenge, e.g. over WiFi or VPN-based LTE
• WebSocket transmit frames: Sent frame-by-frame from your script (via bus.send()). Fully flexible and completely controlled in Python, but the timing is determined client-side and is therefore subject to host/network latency

In short: Use edge-based sequences for precise, repeatable periodic transmission (especially over high-latency links), and WebSocket frames when you need dynamic, script-driven control.

We offer technical support on the basics, i.e. ensuring that you can get started with receiving/transmitting data as per our 'basic' script examples in the python-can documentation.

However, we do not offer technical support on custom scripts or general Python coding. Further, some of the demos we showcase (such as the Grafana-MQTT integration) come without support, though the documentation should make it fairly simple to set up.

No. python-can is a popular open source Python library for CAN bus communication, not something we invented. Instead of building a custom API, we make the CANsub work directly with python-can: Our python-can-cansub package registers the CANsub as a standard python-can interface.

This means the CANsub plugs straight into the entire python-can ecosystem, so all of its tools, add-on packages and existing scripts work out of the box, with no lock-in to a proprietary API.

For working with CANedge log files in Python, see our separate Python MF4 API article, which covers our python-can integration and the Parquet data lake route.

As a supplement to the above Python packages, we also sometimes refer to processing Parquet data lakes in Python, see e.g. our intro to our MF4 decoders. This reflects the fact that we provide simple-to-use executables for DBC decoding CANedge log files to Parquet files. Python can be used to both run the executables (via sub processes) and analyze the Parquet files, which offers a very useful alternative route for analysing data, ideally suited for large-scale data processing.