Home / Solutions Overview / High-Performance FIX Engines & FIXEdge FIX Server / FIX Antenna Python

FIX Engine — FIX Antenna Python

FIX Antenna Python (FA P) is a Python wrapper built on top of FIX Antenna C++. It brings the mature FIX session layer, recovery mechanisms, and protocol handling of the native C++ engine into the Python ecosystem, allowing teams to build FIX applications in Python while relying on a production-grade engine core.

FIX Antenna Python is designed for teams that want Python development productivity without re-implementing FIX session management. Developers can focus on business logic, test harnesses, certification tools, simulators, and workflow integration, while the library handles session creation, logon/logout flow, message delivery, sequence numbers, resend processing, persistence, backup connectivity, and SSL configuration.

The library exposes the same fundamental runtime model as the underlying engine: engine initialization, session creation, acceptor and initiator roles, application callbacks, FIX message manipulation, recovery, configuration, and remote administration. It supports both persistent and transient sessions, message validation, repeating groups, user-defined fields, and FIX 5.0 / FIXT 1.1 session setup through parser configuration.

Access to the Quick Start document can be found here. A free trial version of the software is available in the download section on the page.

Features

Feature	Description
High throughput / Low latency	FIX Antenna Python combines Python development productivity with the proven low-latency FIX session layer of FIX Antenna C++. Built on top of the native FIX Antenna C++ engine Benchmark scenario uses sustained traffic at 50,000 msg/sec Round-trip latency is measured in microseconds Well suited for Python-based trading tools, certification environments, simulators, and business applications requiring production-grade FIX connectivity Latest performance testing results for FIX Antenna Python can be found here.
Built on FIX Antenna C++	Python wrapper over the native FIX Antenna C++ engine Brings a mature production-grade FIX session layer into Python applications Lets developers focus on trading logic, certification tooling, and automation instead of low-level FIX session implementation
Core FIX session functionality	Create multiple FIX sessions Support for both initiator and acceptor roles Session lifecycle management: connect, reconnect, disconnect, finalize Session identifiers support standard SenderCompID / TargetCompID semantics Session Qualifier support is documented in FAQ for running multiple sessions with the same Sender/Target pair
Persistent and transient sessions	Persistent sessions store session state on disk and can be restored after failure Stored state includes session parameters, incoming and outgoing sequence numbers, outgoing messages, and optionally incoming messages Transient sessions use in-memory storage and provide faster operation where recovery is not required Useful for market data or application-managed recovery scenarios
Sequence numbers and session state	Independent incoming and outgoing sequence number handling Session state inspection through API Documented session states include INITIAL, WAIT_FOR_CONNECT, WAIT_FOR_FIRST_LOGON, WAIT_FOR_CONFIRM_LOGON, ESTABLISHED, RECONNECT, SWITCH_CONNECTION and termination states Sequence numbers are restored after non-graceful interruption when persistent storage is used
Recovery and delivery	Recovery section includes Backup connection, Store-and-forward, Gap fill and Fail-over Application-level resend processing is available through callback control FIX Antenna resolves gap fill automatically by default Late delivery vs rejecting behavior is documented at session level
FIX message composition API	Create FIX messages programmatically Get, set, and remove fields by tag Support for repeating groups Support for user-defined fields Copy messages Message validation is documented as part of the session/message model
Application callback model	Application class is used to process incoming business messages and session events Callback-based architecture simplifies integration of business logic into Python services and utilities Delayed processing behavior is supported when the application cannot process an incoming message immediately
SSL / secure connectivity	SSL can be configured through engine.properties SSL can also be configured programmatically Dedicated SSL support is documented for both acceptor and initiator sessions Available SSL configuration objects include protocol selection, ciphers list, certificate and private key configuration
Configuration and administration	Default engine.properties configuration file is included in the package Documentation includes dedicated sections for Configuration and Remote administration Configured sessions can be queried from the engine API Logging and recovery files are stored in the configured log directory
Packaging	The package includes: Native Python module Standard FIX dictionaries *.pyi files for IDE autocompletion Default engine.properties file Samples Programmer’s Guide

FIX Antenna Python Programmer’s Guide

Quick Start

API Reference: FixEngine

API Reference: Application

High Availability

FIX Antenna Python supports application resilience through the recovery capabilities of the underlying FIX Antenna engine and the Python API. The documentation includes dedicated recovery flows for backup connection, store-and-forward, gap fill, and fail-over.

Persistent sessions store session state on disk and can be restored after failure.
Stored state includes session parameters, sequence numbers, and persisted message flow required for session recovery.
Backup connection support is documented as part of the recovery model.
Gap fill is resolved automatically by default, with application-level control over resend processing available through callbacks.
Fail-over behavior is documented as part of the recovery section.

For deployments where full recovery is not required, transient sessions can be used to trade persistence for lower overhead.

Architecture

FIX Antenna Python follows the architecture of the native FIX Antenna engine while exposing it through a Python-friendly API.

The runtime model is centered around several core components: FixEngine for initialization and session creation, Session for FIX connectivity and state handling, Application for business-level callbacks and event processing, and FixMessage for FIX message composition and parsing.

Engine initialization must be performed before any other API calls. The engine is responsible for initializing the runtime, creating sessions, collecting statistics, and cleaning up before exit. Sessions can be created programmatically, configured as acceptors or initiators, and run with either persistent or transient storage models depending on recovery requirements.

This design allows Python applications to use the proven FIX session machinery of the underlying engine while keeping application logic in Python. It is especially suitable for certification tools, simulators, testing harnesses, workflow automation, and business services that need production-grade FIX connectivity without implementing protocol handling from scratch.

APIs

FIX Antenna Python provides the main APIs required to build FIX-enabled Python applications:

Create multiple FIX sessions
Run sessions as initiators or acceptors
Open, reconnect, disconnect, and finalize sessions
Create and manipulate FIX messages
Access and modify fields by tag
Work with repeating groups and user-defined fields
Inspect and control session state and sequence numbers
Use persistent or transient session models
Configure SSL programmatically
Handle incoming business messages and session events through the Application callback model
Access recovery workflows including resend processing, backup connection, store-and-forward, and fail-over
Use configuration and remote administration facilities described in the Programmer’s Guide

full list of FIX Antenna Python APIs

Supported Compilers

Operating System	PYTHON VERSION	64-bit
Windows	PYTHON 3.7/3.10/3.13
Linux RHEL 9	PYTHON 3.7/3.10/3.13
Linux Ubuntu 24.04	PYTHON 3.7/3.10/3.13

Can't find your platform in the table?

sales@b2bits.com contact us

Pricing Overview

We provide cost-effective perpetual and annual licensing options that are tailored specifically to meet your operational needs. These models are customized based on your preferred support level (ranging from business hours to 24x5/7 coverage with varying Service Level Agreements (SLA)), the number of machines required, and your specific deployment environment. Licenses for non-production environments, such as development, testing, and backup, are offered separately at 50% of the cost of a production license.

view licensing models