dYdX Trading Bot in Python

This guide shows how to build a dYdX trading bot in Python with LumiBot, for both AI agent trading and algorithmic trading. LumiBot connects to dYdX through CCXT, the open source library that talks to more than 100 crypto exchanges. You will create a dYdX account and API wallet, connect it, and run two examples: a simple algorithmic trading bot and an agentic trading bot where an AI agent makes the calls.

dYdX at a glance

CCXT exchange id

dydx

Markets

Perpetual swaps

Testnet (sandbox)

Yes

Credentials

private key, wallet address

Live data streams

order book, trades, candles

CCXT request spacing

about 100 ms between requests

Official site

https://www.dydx.xyz

API docs

https://docs.dydx.xyz

Fees

https://docs.dydx.exchange/introduction-trading_fees

What is dYdX?

dYdX is a self-custody (decentralized) trading platform built on its own blockchain, dYdX Chain. It focuses on perpetual futures settled in USDC, and you trade from your own wallet instead of handing coins to a company.

Sign up for dYdX

  1. Open https://dydx.trade and connect your wallet. When you sign with your Ethereum wallet, dYdX creates your dYdX Chain address and its secret phrase.

  2. Add funds to your dYdX account. Positions are margined and settled in USDC.

  3. For practice, use the dYdX testnet at https://v4.testnet.dydx.exchange. Testnet funds come from the faucet at https://faucet.v4testnet.dydx.exchange and only work on testnet.

Open a dYdX account

Set up a dYdX API wallet

  1. Use a separate Ethereum wallet just for the bot, holding only the money you want it to trade.

  2. Connect that wallet on https://dydx.trade and sign. dYdX creates your dYdX Chain address and secret phrase from that signature.

  3. Copy your dYdX address (it starts with dydx1). You can see it by clicking your address in the upper right corner.

  4. Export the private key of that Ethereum wallet from your wallet app. CCXT uses it to rebuild the same dYdX key.

  5. dYdX also offers API Trading Keys (More, then API Trading Keys, then Generate New API Key) that cannot withdraw. CCXT’s dYdX connector does not use them yet, so LumiBot needs the wallet key above.

Which permissions to turn on: dYdX API Trading Keys made in the app can only trade with your cross margin, and dYdX says they cannot withdraw funds or move assets. CCXT’s dYdX connector does not support those keys yet. It signs with your account’s own key, which has full control, including withdrawals. That is why you should use a separate wallet that holds only the money you want the bot to trade, and never share its private key or secret phrase.

Warning

A dYdX private key is as powerful as the money it controls. Use a separate wallet or API wallet that holds only what you want the bot to trade, keep the key out of your code and out of Git, and move your funds if the key ever leaks.

Connect dYdX to LumiBot

The simplest way: put these lines in a .env file next to your strategy. LumiBot loads the file, sees TRADING_BROKER=dydx and connects to dYdX for you, so your strategy needs no broker code.

TRADING_BROKER=dydx
DYDX_PRIVATE_KEY=your_privateKey
DYDX_WALLET_ADDRESS=your_walletAddress
DYDX_SANDBOX=true   # testnet; remove this line for your live account

LumiBot reads exactly the fields CCXT needs for dYdX (privateKey, walletAddress). If one is missing, LumiBot stops at start-up and names the variable you still need.

You can also build the broker in code. This is handy when one script talks to more than one exchange, or when you need extra CCXT options. The keys in the config are CCXT’s own credential names for dYdX:

import os

DYDX_CONFIG = {
    "exchange_id": "dydx",
    "privateKey": os.environ.get("DYDX_PRIVATE_KEY"),
    "walletAddress": os.environ.get("DYDX_WALLET_ADDRESS"),
    "sandbox": True,  # testnet first; set False for your live account
}

from lumibot.brokers import Ccxt

broker = Ccxt(DYDX_CONFIG)
# then: MyStrategy(broker=broker, ...)

Either way, LumiBot turns on CCXT’s built-in rate limiting for you.

Practice on the dYdX testnet

dYdX runs a public testnet with its own site at https://v4.testnet.dydx.exchange and a faucet at https://faucet.v4testnet.dydx.exchange. Set DYDX_SANDBOX=true (or "sandbox": True in a code config) to use it.

CCXT sends sandbox requests to: https://indexer.v4testnet.dydx.exchange/v4, https://test-dydx-rpc.kingnodes.com. Testnet and live accounts use different keys.

Algorithmic trading example: a simple dYdX bot

CCXT lists no spot market for dYdX, so this example trades a perpetual contract. It opens one small long BTC position worth about 50 USDC and then holds it. It is a starting point to check that your keys, balances and orders work. If the exchange’s minimum order is larger, raise the amount. If your account uses hedge mode, add position_side="long" to create_order. dYdX accepts only limit orders through CCXT, so the example places a limit order just above the last price.

from lumibot.entities import Asset
from lumibot.strategies import Strategy


class DydxOpenOneLong(Strategy):
    """Open one small long BTC perpetual position, then hold it."""

    def initialize(self):
        self.sleeptime = "1H"
        self.set_market("24/7")  # crypto trades all day, every day

    def on_trading_iteration(self):
        # The full CCXT symbol keeps the settlement currency clear.
        contract = self.broker.get_asset("BTC/USDC:USDC")
        if self.get_position(contract) is not None:
            return  # already holding the position
        price = self.get_last_price(contract)
        if price:
            # Each contract covers contract.multiplier BTC; size the order to about 50 USDC.
            quantity = round(50 / (price * contract.multiplier), 6)
            # This exchange takes only limit orders through CCXT.
            order = self.create_order(contract, quantity, "buy", limit_price=price * 1.002)
            self.submit_order(order)


if __name__ == "__main__":
    # LumiBot reads TRADING_BROKER and the keys from your .env file.
    strategy = DydxOpenOneLong(quote_asset=Asset("USDC", asset_type=Asset.AssetType.CRYPTO))
    strategy.run_live()

Agentic trading example: an AI agent that trades on dYdX

Agentic trading means an AI agent reads the market and decides what to do. In this example one LumiBot agent looks at prices and your dYdX account, then places the orders itself. There is no Python logic in between: you set the rules in plain English in the prompt, such as what it may trade and how big each order can be. This follows the same pattern as LumiBot’s AI trading team examples.

from lumibot.entities import Asset
from lumibot.strategies import Strategy


class DydxAITrader(Strategy):
    """One AI agent researches the market and places the trades itself."""

    def initialize(self):
        self.sleeptime = "4H"
        self.set_market("24/7")
        self.agents.create(
            name="trader",
            model="openai/gpt-6-luna",
            reasoning_effort="high",
            allow_trading=True,
            system_prompt=(
                "You manage a small crypto account on dYdX. "
                "You may trade the BTC/USDC:USDC perpetual contract (asset_type 'crypto_future'), long or short, or stay flat. "
                "Before every order, call account_portfolio, account_positions and "
                "market_last_price for that exact symbol in the same run. "
                "Keep each order under 10% of the account value. "
                "Explain each decision in one short paragraph."
            ),
        )

    def on_trading_iteration(self):
        self.agents["trader"].run(
            task_prompt="Review recent BTC/USDC:USDC prices and your current position, then decide whether to buy, sell or hold.",
            context={"exchange": "dYdX", "quote": "USDC", "date": self.get_datetime().isoformat()},
        )


if __name__ == "__main__":
    # LumiBot reads TRADING_BROKER and the keys from your .env file.
    strategy = DydxAITrader(quote_asset=Asset("USDC", asset_type=Asset.AssetType.CRYPTO))
    strategy.run_live()

The agent needs a model key such as OPENAI_API_KEY in your environment. See the AI agents quickstart for models, tools and memory.

What you can trade on dYdX through CCXT

Market

Listed by CCXT

Spot

No

Margin

No

Perpetual swaps

Yes

Dated futures

No

Options

No

CCXT lists these order features for dYdX: limit orders, editing open orders, canceling orders.

For perpetual contracts, use the full CCXT symbol so the settlement currency is clear, for example BTC/USDC:USDC. See the CCXT guide for contract quantities, position modes and leverage.

dYdX tips

  • With environment variables, set DYDX_WALLET_ADDRESS to your dYdX Chain address (it starts with dydx1, not your Ethereum 0x address) and DYDX_PRIVATE_KEY to the private key of the Ethereum wallet you connected.

  • dYdX markets are perpetual futures settled in USDC, so use the full CCXT symbol, for example BTC/USDC:USDC.

  • dYdX warns that anyone who knows your secret phrase can send, trade and sell from that account. Store keys offline and never paste them into chats. Use separate keys for each bot.

  • Mainnet data comes from the indexer at https://indexer.dydx.trade/v4, and the testnet indexer is https://indexer.v4testnet.dydx.exchange.

Frequently asked questions

Can I build a dYdX trading bot in Python?

Yes. Install LumiBot (pip install lumibot), set your dYdX keys and use the dydx CCXT exchange id as shown above.

Does dYdX have a testnet?

Yes. Set DYDX_SANDBOX=true and use keys from the dYdX testnet.

Which keys does a dYdX bot need?

dYdX API Trading Keys made in the app can only trade with your cross margin, and dYdX says they cannot withdraw funds or move assets. CCXT’s dYdX connector does not support those keys yet. It signs with your account’s own key, which has full control, including withdrawals. That is why you should use a separate wallet that holds only the money you want the bot to trade, and never share its private key or secret phrase.

Can an AI agent trade on dYdX by itself?

Yes. The agentic example above gives one agent permission to trade. You control what it may trade and how much through its prompt.

Can I trade dYdX perpetual futures with LumiBot?

CCXT lists perpetual swaps for this exchange. Use the full contract symbol, such as BTC/USDC:USDC.

Is LumiBot free?

Yes. LumiBot is open source on GitHub at https://github.com/Lumiwealth/lumibot. You pay only your exchange’s trading fees and, for AI agents, your model provider.

Run it in the cloud with BotSpot

Do not want to keep a computer running for your dYdX bot? BotSpot is the hosted home for LumiBot strategies and AI trading agents: build with AI, backtest, connect a broker, and watch every trade with logs and alerts.

Try BotSpot

Sources