Forem: hoon6653

Bybit API Python Tutorial: Authentication, Orders, and Position Management

hoon6653 — Tue, 14 Apr 2026 01:07:58 +0000

Bybit API Python Tutorial: Authentication, Orders, and Position Management

The Bybit V5 API is one of the more capable exchange APIs available to retail algo traders — it supports spot, linear and inverse futures, options, and a unified account model, all under a single endpoint hierarchy. The pybit library wraps it cleanly for Python.

This tutorial covers the full workflow for a Python trading bot: authenticating with the Bybit V5 API, placing market and limit orders, monitoring open positions, handling errors and rate limits, and structuring your code for production. No prior exchange API experience required.

By the end you'll have working code for every step. For a production example that uses this exact API under a 3-domain architecture with an AI strategy gate, the full source is at hoon6653/autotrading.

Prerequisites and Setup

Python version: 3.10+ (this tutorial uses 3.11, matching the production server environment)

Bybit account: You'll need API keys from Bybit — start with testnet keys (free, no deposit required).

Install pybit:

pip install pybit

pybit is the official Bybit Python SDK. It handles request signing, timestamp generation, and V5 endpoint routing. Current version: 5.7+.

API Keys:

Log in to testnet.bybit.com (paper money — use this first)
Navigate to Account → API Management → Create New Key
Select "System-generated API Keys"
Permissions needed: Read + Trade (for orders and positions)
Copy the key and secret — you only see the secret once

Testnet vs mainnet: Testnet keys only work with testnet=True. Mainnet keys only work with testnet=False. Mixing them gives retCode: 10003.

Store keys in environment variables, not in source code:

export BYBIT_API_KEY="your_key_here"
export BYBIT_API_SECRET="your_secret_here"

Authenticating with the Bybit V5 API in Python

Initializing the HTTP Session

import os
from pybit.unified_trading import HTTP

session = HTTP(
    testnet=True,  # Switch to False for mainnet
    api_key=os.environ["BYBIT_API_KEY"],
    api_secret=os.environ["BYBIT_API_SECRET"],
)

The HTTP class from pybit.unified_trading targets the Bybit V5 unified endpoint. It handles:

HMAC-SHA256 request signing
Timestamp injection (avoids clock drift issues)
Response parsing to Python dicts

Verifying Authentication

Test with a wallet balance check — this requires a signed request:

try:
    response = session.get_wallet_balance(accountType="UNIFIED")
    print("Auth OK. Balance:", response["result"]["list"][0]["totalEquity"])
except Exception as e:
    print("Auth failed:", e)

Expected success output:

Auth OK. Balance: 10000.0

If you see retCode: 10003, you have a testnet/mainnet key mismatch. See the common Bybit API errors guide for fixes.

Fetching Market Data (No Auth Required)

Some endpoints are public — useful for verifying connectivity before testing authenticated calls.

Current Price

ticker = session.get_tickers(category="linear", symbol="BTCUSDT")
price = float(ticker["result"]["list"][0]["lastPrice"])
print(f"BTC price: ${price:,.2f}")

Instrument Info (for order sizing constraints)

Before placing any order, fetch the instrument's lot size constraints:

info = session.get_instruments_info(category="linear", symbol="BTCUSDT")
lot_filter = info["result"]["list"][0]["lotSizeFilter"]

qty_step = lot_filter["qtyStep"]       # "0.001"
min_qty  = lot_filter["minOrderQty"]   # "0.001"
max_qty  = lot_filter["maxOrderQty"]   # "100"

print(f"Step: {qty_step}, Min: {min_qty}, Max: {max_qty}")

Always round order quantities to qtyStep using Decimal (not round()) to avoid retCode: 10001:

from decimal import Decimal, ROUND_DOWN

def safe_qty(qty: float, step: str) -> str:
    return str(Decimal(str(qty)).quantize(Decimal(step), rounding=ROUND_DOWN))

# Examples:
safe_qty(0.0037, "0.001")  # → "0.003"
safe_qty(0.005,  "0.001")  # → "0.005"

Placing Orders with pybit

Market Order (Linear Futures)

A market order executes immediately at the best available price:

order = session.place_order(
    category="linear",
    symbol="BTCUSDT",
    side="Buy",          # "Buy" or "Sell"
    orderType="Market",
    qty="0.001",         # BTC quantity — must match qtyStep
    timeInForce="IOC",   # Immediate-or-cancel for market orders
)

if order["retCode"] == 0:
    order_id = order["result"]["orderId"]
    print(f"Market order placed: {order_id}")
else:
    print(f"Order failed: {order['retMsg']}")

Market Order (Spot)

Spot orders use category="spot" and can specify quoteOrderQty (spend X USDT) instead of qty:

# Buy with a fixed USDT amount
order = session.place_order(
    category="spot",
    symbol="BTCUSDT",
    side="Buy",
    orderType="Market",
    quoteOrderQty="50",  # Spend 50 USDT
)

Limit Order

A limit order sits in the order book until filled at your specified price or better:

current_price = 65000.0
limit_price = current_price * 0.99  # 1% below current price

order = session.place_order(
    category="linear",
    symbol="BTCUSDT",
    side="Buy",
    orderType="Limit",
    qty="0.001",
    price=str(round(limit_price, 2)),  # Price as string
    timeInForce="GTC",                 # Good-till-cancelled
)

Limit Order with Stop-Loss and Take-Profit

order = session.place_order(
    category="linear",
    symbol="BTCUSDT",
    side="Buy",
    orderType="Limit",
    qty="0.001",
    price="64000",
    timeInForce="GTC",
    stopLoss="62000",          # Auto-close if price drops to 62k
    takeProfit="68000",        # Auto-close if price rises to 68k
    slTriggerBy="LastPrice",   # Trigger condition
    tpTriggerBy="LastPrice",
)

Checking Order Status

order_detail = session.get_order_history(
    category="linear",
    orderId=order_id,
)
status = order_detail["result"]["list"][0]["orderStatus"]
# "New" → open, "Filled" → executed, "Cancelled" → cancelled
print(f"Order status: {status}")

Cancelling an Order

cancel_result = session.cancel_order(
    category="linear",
    symbol="BTCUSDT",
    orderId=order_id,
)
if cancel_result["retCode"] == 0:
    print("Order cancelled")

Managing Open Positions

Fetching All Open Positions

positions = session.get_positions(
    category="linear",
    settleCoin="USDT",  # or specific symbol: symbol="BTCUSDT"
)

for pos in positions["result"]["list"]:
    if float(pos["size"]) > 0:
        print(
            f"{pos['symbol']} {pos['side']}: "
            f"size={pos['size']}, "
            f"entry={pos['avgPrice']}, "
            f"unrealizedPnl={pos['unrealisedPnl']}"
        )

Sample output:

BTCUSDT Buy: size=0.001, entry=64250.5, unrealizedPnl=3.25

Closing a Position

Close by placing a market order on the opposite side with reduceOnly=True:

def close_position(session, symbol: str, size: str, side: str) -> dict:
    """Close an open position at market price."""
    close_side = "Sell" if side == "Buy" else "Buy"
    return session.place_order(
        category="linear",
        symbol=symbol,
        side=close_side,
        orderType="Market",
        qty=size,
        reduceOnly=True,   # Prevents accidentally flipping the position
        timeInForce="IOC",
    )

# Usage
pos = positions["result"]["list"][0]
result = close_position(session, pos["symbol"], pos["size"], pos["side"])

Setting Stop-Loss on an Existing Position

session.set_trading_stop(
    category="linear",
    symbol="BTCUSDT",
    stopLoss="62000",
    slTriggerBy="LastPrice",
    positionIdx=0,  # 0=one-way mode, 1=hedge long, 2=hedge short
)

Error Handling and Rate Limits

Checking retCode on Every Response

Never assume a request succeeded. Always check retCode:

def checked(response: dict, context: str = "") -> dict:
    """Raise on non-zero retCode."""
    if response.get("retCode") != 0:
        raise RuntimeError(
            f"{context} failed: [{response['retCode']}] {response['retMsg']}"
        )
    return response

# Usage
response = checked(
    session.place_order(category="linear", symbol="BTCUSDT", ...),
    context="BTCUSDT market buy"
)

Rate Limit Headers

Bybit returns rate limit info in HTTP response headers:

Header	Meaning
`X-Bapi-Limit`	Total allowed requests per window
`X-Bapi-Limit-Status`	Remaining requests
`X-Bapi-Limit-Reset-Timestamp`	Window reset time (ms)

pybit exposes the raw response via .headers if you make raw calls. For most bots, the practical limit is: don't make more than 10 order-related requests per second on a single symbol.

Retry Pattern for Rate Limits (retCode 10006)

import time
import random

def call_with_retry(fn, *args, max_retries=4, **kwargs) -> dict:
    for attempt in range(max_retries):
        result = fn(*args, **kwargs)
        if result.get("retCode") == 10006:
            wait = (2 ** attempt) + random.uniform(0, 0.5)
            time.sleep(wait)
            continue
        return result
    raise RuntimeError("Rate limit retry exhausted")

# Usage
order = call_with_retry(
    session.place_order,
    category="linear",
    symbol="BTCUSDT",
    side="Buy",
    orderType="Market",
    qty="0.001",
)

Common retCode Reference

retCode	Meaning	Fix
0	Success	—
10001	Parameter error	Check qty step size, price format
10003	Invalid API key	Testnet/mainnet key mismatch
10004	Signature error	Sync system clock with NTP
10006	Rate limit	Exponential backoff
110001	Instrument not found	Check symbol spelling
110007	Insufficient balance	Check wallet balance
110043	reduceOnly rejected	No matching open position to reduce

Structuring for a Real Bot

A one-off script is fine for testing. A production bot needs a few extra patterns.

Config Dataclass

from dataclasses import dataclass

@dataclass
class BotConfig:
    symbol: str = "BTCUSDT"
    category: str = "linear"
    max_position_usdt: float = 100.0   # Max notional per trade
    min_confidence: float = 0.70       # For AI gate integration
    testnet: bool = True               # Flip for mainnet

Session Factory

def make_session(config: BotConfig) -> HTTP:
    return HTTP(
        testnet=config.testnet,
        api_key=os.environ["BYBIT_API_KEY"],
        api_secret=os.environ["BYBIT_API_SECRET"],
    )

Position Size Calculator

Size to notional value — respects max position limit and step size:

def calc_qty(usdt_amount: float, price: float, qty_step: str) -> str:
    raw = usdt_amount / price
    return safe_qty(raw, qty_step)  # safe_qty defined earlier

# Example: $100 at $65,000/BTC with 0.001 step → "0.001"
qty = calc_qty(100.0, 65000.0, "0.001")

Next Steps: From One-Off Script to a Running Bot

This bybit api python tutorial covers the core operations: auth, orders, positions, error handling. The natural next step is to build the decision layer — what tells the bot when to buy or sell.

One approach is rule-based (RSI crossovers, moving average signals). Another is the pattern used in AutoTrading: a fail-closed AI gate that uses Claude Haiku at runtime to select from a set of pre-defined strategies — or explicitly refuse to trade when market conditions are ambiguous.

The fail-closed gate is covered in detail here: Claude Haiku as a Runtime Trading Gate, Not a Bot Builder.

For a deeper look at the pybit library itself — WebSocket, async, session config options — see the pybit Library: Complete Python Developer Guide.

Before going to mainnet, validate your logic on Bybit testnet — paper money, same V5 API.

For a comparison of different bot architectures (AutoTrading vs freqtrade vs Jesse vs Hummingbot), see docs/comparison.md.

The full AutoTrading source — Python 3.11, FastAPI backend, React 19 dashboard, 927 pytest tests, Oracle Cloud deployment — is open source:

→ github.com/hoon6653/autotrading

Ready to try it? Create a free Bybit account and generate testnet API keys to run the code in this tutorial. Want to compare exchanges? OKX also offers a comprehensive trading API.

FAQ

pybit vs ccxt for Bybit?

Both work. ccxt is a multi-exchange library — good if you want to support Binance, Kraken, and Bybit under one interface. pybit is Bybit-specific and exposes more V5 API features directly (hedge mode, unified account, advanced order types). For a Bybit-only bot, pybit is the better choice.

How do I switch from testnet to mainnet?

Change testnet=True to testnet=False in your HTTP() call and swap your API keys (BYBIT_API_KEY / BYBIT_API_SECRET) for mainnet keys. Nothing else changes.

Can I use async/await with pybit?

Yes. Use pybit.unified_trading.AsyncHTTP instead of HTTP. The method signatures are identical — prefix calls with await. For WebSocket, use pybit.unified_trading.WebSocket with asyncio.

from pybit.unified_trading import AsyncHTTP
import asyncio

async def get_balance():
    session = AsyncHTTP(testnet=True, api_key=..., api_secret=...)
    return await session.get_wallet_balance(accountType="UNIFIED")

asyncio.run(get_balance())

Do I need a VPN or proxy to use the Bybit API?

Bybit blocks access from certain jurisdictions (US, UK, Ontario). If you're in a restricted region, a VPS in a permitted jurisdiction is the standard workaround. The Oracle Cloud server used in AutoTrading runs in Japan.

What's the difference between one-way mode and hedge mode?

One-way mode (default) means you can only hold one direction per symbol at a time. Hedge mode lets you hold a long and short simultaneously on the same symbol. Set via set_leverage with buyLeverage and sellLeverage, or change in Bybit's UI under Derivatives → Position Mode.

SEO Metadata

Title Tag: Bybit API Python Tutorial: Authentication, Orders, and Position Management (79 chars — truncate to: Bybit API Python Tutorial: Auth, Orders, Positions)
Meta Description: Complete Bybit API Python tutorial: authenticate with pybit, place market and limit orders, manage open positions, handle errors and rate limits. Bybit V5 API guide. (167 chars)
Primary Keyword: bybit api python tutorial (used 5×)
Secondary Keywords: bybit v5 api python, pybit library tutorial, bybit python bot, pybit place order

Schema Markup

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "Bybit API Python Tutorial: Authentication, Orders, and Position Management",
  "description": "Complete guide to using the Bybit V5 API in Python: authenticate with pybit, place market and limit orders, manage positions, and handle errors.",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Install pybit and generate API keys",
      "text": "Run pip install pybit. Generate API keys at testnet.bybit.com. Store keys in environment variables."
    },
    {
      "@type": "HowToStep",
      "name": "Authenticate with the Bybit V5 API",
      "text": "Initialize pybit.unified_trading.HTTP with testnet=True/False and your api_key/api_secret. Verify with get_wallet_balance()."
    },
    {
      "@type": "HowToStep",
      "name": "Fetch instrument constraints",
      "text": "Call get_instruments_info() to get qtyStep and minOrderQty. Round all order quantities down to qtyStep using Decimal.quantize."
    },
    {
      "@type": "HowToStep",
      "name": "Place market and limit orders",
      "text": "Use session.place_order() with category, symbol, side, orderType, qty. Always check retCode == 0 in the response."
    },
    {
      "@type": "HowToStep",
      "name": "Manage open positions",
      "text": "Use get_positions() to list open positions. Close with a reduceOnly market order on the opposite side."
    },
    {
      "@type": "HowToStep",
      "name": "Handle errors and rate limits",
      "text": "Check retCode on every response. Implement exponential backoff for retCode 10006. Use checked() wrapper to raise on failure."
    }
  ]
}

Image Suggestions

Hero: Diagram of the Python → pybit → Bybit V5 API call chain with arrows showing auth → order → position flow
Auth section: Screenshot of Bybit API Management page (testnet vs mainnet toggle visible)
Order section: Side-by-side comparison of market vs limit order book placement
Position section: Screenshot of a parsed position dict in Python terminal output with unrealizedPnl highlighted

7 Bybit API Python Errors and How to Fix Them

hoon6653 — Wed, 08 Apr 2026 12:10:31 +0000

If you're building a Bybit trading bot in Python, you will hit errors. The Bybit V5 API is well-documented, but the error messages are often terse retCode integers that require digging through docs to decode.

This guide covers the 7 most common Bybit API Python errors — the exact error output, the root cause, and a working fix you can paste in.

All code uses the pybit library (pip install pybit). If you're evaluating different bot architectures, see how AutoTrading compares to freqtrade and Jesse.

Error 1: `retCode: 10003` — Invalid API Key

Error output:

{"retCode": 10003, "retMsg": "API key is invalid.", "result": {}}

Root cause: You're using a testnet API key against the mainnet endpoint (or vice versa).

Fix: Bybit testnet and mainnet require separate API keys. The pybit HTTP session takes a testnet boolean — make sure it matches the key you generated.

from pybit.unified_trading import HTTP

# Testnet session — must use testnet keys
session = HTTP(
    testnet=True,
    api_key="YOUR_TESTNET_KEY",
    api_secret="YOUR_TESTNET_SECRET",
)

# Mainnet session — must use mainnet keys
session = HTTP(
    testnet=False,
    api_key="YOUR_MAINNET_KEY",
    api_secret="YOUR_MAINNET_SECRET",
)

Always start with testnet=True and paper-trade before switching to mainnet. If you don't have an account yet, create a free Bybit account here.

Error 2: `retCode: 10006` — Rate Limit Exceeded

Error output:

{"retCode": 10006, "retMsg": "Too many visits!", "result": {}}

Root cause: Your bot is hitting the endpoint faster than Bybit's rate limit allows (varies by endpoint, typically 10–120 req/s).

Fix: Implement exponential backoff with jitter. Check the X-Bapi-Limit-Status response header to monitor your remaining quota.

import time
import random

def call_with_backoff(fn, max_retries=5, *args, **kwargs):
    for attempt in range(max_retries):
        result = fn(*args, **kwargs)
        if result.get("retCode") == 10006:
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Waiting {wait:.1f}s...")
            time.sleep(wait)
            continue
        return result
    raise RuntimeError("Max retries exceeded")

Error 3: `retCode: 10001` — Parameter Error (qty step size)

Error output:

{"retCode": 10001, "retMsg": "params error: qty is not correct", "result": {}}

Root cause: Your order quantity doesn't match the instrument's qtyStep or minOrderQty. Every Bybit instrument has minimum and step constraints.

Fix: Fetch instrument info first and round your quantity to the allowed step size.

from decimal import Decimal, ROUND_DOWN

def round_qty(qty: float, qty_step: str) -> str:
    """Round quantity down to the instrument's qtyStep."""
    step = Decimal(qty_step)
    rounded = Decimal(str(qty)).quantize(step, rounding=ROUND_DOWN)
    return str(rounded)

# Fetch constraints
info = session.get_instruments_info(category="linear", symbol="BTCUSDT")
lot_filter = info["result"]["list"][0]["lotSizeFilter"]
qty_step = lot_filter["qtyStep"]        # e.g. "0.001"
min_qty = lot_filter["minOrderQty"]     # e.g. "0.001"

# Safe order quantity
raw_qty = 0.0037
safe_qty = round_qty(raw_qty, qty_step)  # → "0.003"

Error 4: Signature Mismatch

Error output:

{"retCode": 10004, "retMsg": "error sign! verify the signature!", "result": {}}

Root cause: Your system clock is drifted — Bybit requires the request timestamp to be within 5,000ms of server time.

Fix: Sync your clock or use Bybit's server time to generate timestamps. pybit handles signing automatically, but if you're making raw requests, use this pattern:

import time
import requests

def get_bybit_server_time() -> int:
    r = requests.get("https://api.bybit.com/v5/market/time")
    return int(r.json()["result"]["timeNano"]) // 1_000_000  # → ms

def get_safe_timestamp() -> int:
    """Use server time if local clock may be drifted."""
    return get_bybit_server_time()

On Linux/Oracle Cloud servers, keep NTP synced: sudo timedatectl set-ntp true.

Error 5: `SSL: CERTIFICATE_VERIFY_FAILED`

Error output:

requests.exceptions.SSLError: HTTPSConnectionPool(...):
  SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate

Root cause: Your certifi CA bundle is outdated or missing.

Fix: Update certifi and rebuild the SSL context.

pip install --upgrade certifi pybit requests

If you're on macOS and seeing this from the system Python, run the certificate installer:

/Applications/Python\ 3.x/Install\ Certificates.command

For Docker deployments, add to your Dockerfile:

RUN pip install --upgrade certifi

Error 6: WebSocket Silent Disconnect

Symptom: No error is raised, but your WebSocket stops receiving data after a few minutes.

Root cause: Bybit's WebSocket server requires a heartbeat ping every 20 seconds. Without it, the server silently drops the connection.

Fix: Send a ping message on a timer. pybit's WebSocket class handles this automatically if you use it correctly — the silent disconnect usually happens when wrapping the connection manually.

import asyncio
import json
import websockets

async def bybit_ws_with_heartbeat(url: str, subscription: dict):
    async with websockets.connect(url) as ws:
        await ws.send(json.dumps(subscription))

        async def heartbeat():
            while True:
                await asyncio.sleep(20)
                await ws.send(json.dumps({"op": "ping"}))

        asyncio.create_task(heartbeat())

        async for message in ws:
            data = json.loads(message)
            if data.get("op") == "pong":
                continue  # heartbeat ack, ignore
            yield data

For production use, also implement reconnection logic — wrap the outer connection in a while True with an exponential backoff on websockets.ConnectionClosed.

Error 7: USDT vs USDC Margin Confusion

Error output:

{"retCode": 10001, "retMsg": "params error: the account type does not support this coin margin"}

Root cause: Bybit supports both USDT-margined and USDC-margined contracts on linear perpetuals. Mixing settleCoin causes parameter errors.

Fix: Explicitly set settleCoin to match your account's margin type. Check your Unified Trading Account's default settlement currency in Bybit's UI first.

# USDT-margined — most common for spot and linear futures
order = session.place_order(
    category="linear",
    symbol="BTCUSDT",
    side="Buy",
    orderType="Market",
    qty="0.001",
    # settleCoin defaults to USDT for BTCUSDT — usually fine to omit
)

# USDC-margined — explicit
order = session.place_order(
    category="linear",
    symbol="BTCPERP",
    side="Buy",
    orderType="Market",
    qty="0.001",
    settleCoin="USDC",
)

Rule of thumb: if the symbol ends in USDT, you're USDT-margined. If it ends in PERP, check your account default.

FAQ

Which pybit version should I use?

pybit >= 5.7.0 supports the Bybit V5 API. Earlier versions use the V3 endpoint, which Bybit has deprecated. Run pip install --upgrade pybit to get the latest.

How do I debug retCodes I don't recognize?

Check the Bybit V5 API error code reference. For retCode ranges: 10000–10099 are auth/general, 110000+ are order errors.

Is there a way to test without placing real orders?

Yes — Bybit's testnet (testnet.bybit.com) is a full sandbox with paper money. Generate separate API keys there and use testnet=True in your pybit session. You can also use orderType="Limit" with prices far from market to create "safe" test orders on mainnet that won't fill.

How do I handle multiple errors in a production bot?

Wrap each API call in a handler that checks retCode and routes to the appropriate recovery action. For rate limits (10006): backoff. For auth errors (10003, 10004): alert and halt. For parameter errors (10001): log and skip the trade. Never silently swallow errors — at minimum log retCode + retMsg + symbol + qty for every failed call.

Conclusion

These 7 errors cover the majority of what you'll hit building a Bybit trading bot with Python. The pattern is consistent: check retCode, look up the cause, apply the fix. Most are configuration issues (wrong key environment, wrong step size, expired cert) rather than logic bugs.

If you want to see how these fixes integrate into a production bot — with 3 trading domains, a FastAPI backend, and a Claude Haiku AI strategy gate — the full source is open:

→ hoon6653/autotrading on GitHub — Python 3.11, 927 tests, Oracle Cloud deployment

And if the AI gate concept is new to you, read: Claude Haiku as a Runtime Trading Gate, Not a Bot Builder — why REFUSE is the most valuable output a trading AI can produce.

Getting started with Bybit? Sign up for a free account to get your API keys and start building. If you're exploring alternatives, OKX is another solid exchange with a Python-friendly API.

Forem: hoon6653

Bybit API Python Tutorial: Authentication, Orders, and Position Management

Bybit API Python Tutorial: Authentication, Orders, and Position Management

Prerequisites and Setup

Authenticating with the Bybit V5 API in Python

Initializing the HTTP Session

Verifying Authentication

Fetching Market Data (No Auth Required)

Current Price

Instrument Info (for order sizing constraints)

Placing Orders with pybit

Market Order (Linear Futures)

Market Order (Spot)

Limit Order

Limit Order with Stop-Loss and Take-Profit

Checking Order Status

Cancelling an Order

Managing Open Positions

Fetching All Open Positions

Closing a Position

Setting Stop-Loss on an Existing Position

Error Handling and Rate Limits

Checking retCode on Every Response

Rate Limit Headers

Retry Pattern for Rate Limits (retCode 10006)

Common retCode Reference

Structuring for a Real Bot

Config Dataclass

Session Factory

Position Size Calculator

Next Steps: From One-Off Script to a Running Bot

FAQ

pybit vs ccxt for Bybit?

How do I switch from testnet to mainnet?

Can I use async/await with pybit?

Do I need a VPN or proxy to use the Bybit API?

What's the difference between one-way mode and hedge mode?

SEO Metadata

Schema Markup

Image Suggestions

7 Bybit API Python Errors and How to Fix Them

Error 1: retCode: 10003 — Invalid API Key

Error 2: retCode: 10006 — Rate Limit Exceeded

Error 3: retCode: 10001 — Parameter Error (qty step size)

Error 4: Signature Mismatch

Error 5: SSL: CERTIFICATE_VERIFY_FAILED

Error 6: WebSocket Silent Disconnect

Error 7: USDT vs USDC Margin Confusion

FAQ

Which pybit version should I use?

How do I debug retCodes I don't recognize?

Is there a way to test without placing real orders?

How do I handle multiple errors in a production bot?

Conclusion

Error 1: `retCode: 10003` — Invalid API Key

Error 2: `retCode: 10006` — Rate Limit Exceeded

Error 3: `retCode: 10001` — Parameter Error (qty step size)

Error 5: `SSL: CERTIFICATE_VERIFY_FAILED`