# How to Connect to Binance for Live Trading with Nautilus Trader

> Connect to Binance for live trading with Nautilus Trader. Follow our guide to set up API credentials, register clients, and launch your event-driven trading engine for seamless execution.

- Repository: [Nautech Systems/nautilus_trader](https://github.com/nautechsystems/nautilus_trader)
- Tags: how-to-guide
- Published: 2026-02-16

---

**To connect to Binance for live trading, instantiate `BinanceDataClientConfig` and `BinanceExecClientConfig` with your API credentials, register the `BinanceLiveDataClientFactory` and `BinanceLiveExecClientFactory` with a `TradingNode`, then invoke `build()` and `run()` to start the event-driven trading engine.**

Connecting to Binance for live trading in the `nautechsystems/nautilus_trader` ecosystem requires configuring the official Binance adapter. This adapter abstracts HTTP REST and WebSocket connectivity, authentication, and order management into a unified interface that integrates with the platform's event-driven architecture.

## Understanding the Binance Adapter Architecture

The Binance adapter in `nautilus_trader` provides three distinct layers that enable fully-functional live trading:

### Configuration Layer

The `BinanceDataClientConfig` and `BinanceExecClientConfig` classes, defined in [`nautilus_trader/adapters/binance/config.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/config.py), specify authentication credentials, HTTP/WebSocket endpoints, account types (spot, USDT-futures, coin-futures), and environment settings (live, demo, testnet).

### Factory Layer

The `BinanceLiveDataClientFactory` and `BinanceLiveExecClientFactory`, located in [`nautilus_trader/adapters/binance/factories.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/factories.py), instantiate the concrete data-feed and execution client objects that the trading node consumes.

### Live Node Wiring

The `TradingNode` class from [`nautilus_trader/live/node.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/live/node.py) consumes the configuration objects, registers the factories, builds the data and execution pipelines, and runs the event-driven engine that processes market data and order events.

## Step-by-Step Connection Flow

Follow these five steps to connect to Binance for live trading:

1. **Provide Binance credentials** — Set the environment variables `BINANCE_API_KEY` and `BINANCE_API_SECRET` (recommended: Ed25519 private key), or pass credentials directly into the configuration objects.

2. **Create a `TradingNodeConfig`** — Include `data_clients` and `exec_clients` entries keyed by the constant `BINANCE`. Specify the `account_type` (`BinanceAccountType.SPOT`, `USDT_FUTURES`, or `COIN_FUTURES`) and `environment` (`LIVE`, `DEMO`, or `TESTNET`).

3. **Instantiate the `TradingNode`** — Pass the configuration to the `TradingNode` constructor.

4. **Register the Binance factories** — Call `node.add_data_client_factory(BINANCE, BinanceLiveDataClientFactory)` and `node.add_exec_client_factory(BINANCE, BinanceLiveExecClientFactory)`.

5. **Build and run** — Invoke `node.build()` to wire clients into the message bus and data engine, then `node.run()` to start the async loops that maintain HTTP REST and WebSocket connections and process strategy events.

## Minimal Live Trading Example for Binance Spot

The following example demonstrates the minimal code required to connect to Binance Spot for live trading:

```python
from nautilus_trader.adapters.binance import (
    BINANCE,
    BinanceAccountType,
    BinanceDataClientConfig,
    BinanceExecClientConfig,
    BinanceLiveDataClientFactory,
    BinanceLiveExecClientFactory,
)
from nautilus_trader.config import TradingNodeConfig
from nautilus_trader.live.node import TradingNode

# 1️⃣  Provide credentials via env vars or here directly

# export BINANCE_API_KEY="my_key"

# export BINANCE_API_SECRET="$(cat binance_ed25519_private.pem)"

# 2️⃣  Build the node configuration

config = TradingNodeConfig(
    trader_id="MY_TRADER",
    # … other global config like logging, risk, etc.

    data_clients={
        BINANCE: BinanceDataClientConfig(
            api_key=None,               # falls back to env var

            api_secret=None,            # falls back to env var

            account_type=BinanceAccountType.SPOT,
            environment=None,           # defaults to LIVE

        ),
    },
    exec_clients={
        BINANCE: BinanceExecClientConfig(
            api_key=None,
            api_secret=None,
            account_type=BinanceAccountType.SPOT,
            environment=None,
        ),
    },
)

# 3️⃣  Create the live trading node

node = TradingNode(config=config)

# 4️⃣  Wire Binance factories

node.add_data_client_factory(BINANCE, BinanceLiveDataClientFactory)
node.add_exec_client_factory(BINANCE, BinanceLiveExecClientFactory)

# 5️⃣  Build the internal engine and start the event loop

node.build()
node.run()          # blocks until Ctrl‑C, then clean‑up is performed automatically

```

*The same pattern works for USDT‑Futures or Coin‑Futures – just change `account_type` to `BinanceAccountType.USDT_FUTURES` (or `COIN_FUTURES`).*

## Full-Featured Example and Key Files

A ready-to-run script that attaches a simple execution tester strategy is provided in the repository at:

[[`examples/live/binance/binance_spot_exec_tester.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/examples/live/binance/binance_spot_exec_tester.py)](https://github.com/nautechsystems/nautilus_trader/blob/develop/examples/live/binance/binance_spot_exec_tester.py)

This example demonstrates instrument ID creation (`InstrumentId.from_str("ETHUSDT.BINANCE")`), strategy registration (`node.trader.add_strategy(strategy)`), and graceful shutdown handling.

The following table lists the essential source files that implement the Binance live trading connection:

| File | Purpose |
|------|---------|
| [`nautilus_trader/adapters/binance/__init__.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/__init__.py) | Re-exports constants, config classes, factories, and custom data types for convenient imports. |
| [`nautilus_trader/adapters/binance/config.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/config.py) | Defines `BinanceDataClientConfig` and `BinanceExecClientConfig` for authentication, endpoints, and account settings. |
| [`nautilus_trader/adapters/binance/factories.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/factories.py) | Implements `BinanceLiveDataClientFactory` and `BinanceLiveExecClientFactory` for client instantiation. |
| [`nautilus_trader/live/node.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/live/node.py) | Contains `TradingNode` which orchestrates configuration, factory registration, and the event-driven engine. |
| [`examples/live/binance/binance_spot_exec_tester.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/examples/live/binance/binance_spot_exec_tester.py) | Working example of live trading setup with strategy attachment. |

## Summary

- **Use the Binance adapter** (`nautilus_trader/adapters/binance`) to connect to Binance for live trading without implementing low-level HTTP or WebSocket handling.
- **Configure credentials** via environment variables (`BINANCE_API_KEY`, `BINANCE_API_SECRET`) or directly in `BinanceDataClientConfig` and `BinanceExecClientConfig`.
- **Select account type** by setting `account_type` to `BinanceAccountType.SPOT`, `USDT_FUTURES`, or `COIN_FUTURES` in both data and execution configurations.
- **Register factories** with the `TradingNode` using `add_data_client_factory()` and `add_exec_client_factory()` before calling `build()` and `run()`.
- **Reference the example** at [`examples/live/binance/binance_spot_exec_tester.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/examples/live/binance/binance_spot_exec_tester.py) for a complete implementation including strategy registration.

## Frequently Asked Questions

### Do I need Ed25519 keys to connect to Binance with Nautilus Trader?

While RSA keys are supported, Binance recommends **Ed25519 API keys** for enhanced security and performance. Set your Ed25519 private key as the `BINANCE_API_SECRET` environment variable or pass it directly to the configuration objects. The adapter handles signature generation automatically according to the implementation in [`nautilus_trader/adapters/binance/config.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/config.py).

### Can I trade Binance Futures (USDT-M and Coin-M) using the same adapter?

Yes. The Binance adapter supports **Spot**, **USDT Futures (USDT-M)**, and **Coin Futures (Coin-M)** through the same configuration classes. Change the `account_type` parameter in both `BinanceDataClientConfig` and `BinanceExecClientConfig` to `BinanceAccountType.USDT_FUTURES` or `BinanceAccountType.COIN_FUTURES` to switch markets. The factory layer automatically instantiates the appropriate client variants.

### How does the TradingNode handle reconnections and rate limits?

The `TradingNode` delegates connection resilience to the internal Binance client implementations in the adapter. These clients include **automatic reconnection logic** for WebSocket feeds and **token-bucket rate limiting** for REST API calls. You can configure rate limit parameters in the config classes, but the defaults follow Binance's official limits as implemented in [`nautilus_trader/adapters/binance/factories.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/nautilus_trader/adapters/binance/factories.py).

### Where can I find a complete working example of Binance live trading?

The repository provides a ready-to-run script at [`examples/live/binance/binance_spot_exec_tester.py`](https://github.com/nautechsystems/nautilus_trader/blob/main/examples/live/binance/binance_spot_exec_tester.py). This example demonstrates the complete setup including `TradingNode` configuration, factory registration, strategy attachment via `node.trader.add_strategy()`, and graceful shutdown handling. Copy this file, configure your API credentials, and run it directly to see live order submissions on Binance Spot.