pip install ccxt

import ccxt

# List all available exchanges
print(f"Supported exchanges: {len(ccxt.exchanges)}")
# Output: Supported exchanges: 100+

# Public access (no API keys needed)
binance_public = ccxt.binance({'enableRateLimit': True})
ticker = binance_public.fetch_ticker('BTC/USDT')
print(f"BTC price: ${ticker['last']:,.2f}")

# Authenticated access (for trading)
binance = ccxt.binance({
    'apiKey': 'your_api_key',
    'secret': 'your_secret',
    'enableRateLimit': True,
    'options': {'defaultType': 'spot'},
})

import pandas as pd

def get_ohlcv(exchange_id: str, symbol: str,
              timeframe: str = '1h', limit: int = 500):
    """Fetch OHLCV data from any exchange."""
    exchange = getattr(ccxt, exchange_id)({
        'enableRateLimit': True
    })

    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)

    df = pd.DataFrame(
        ohlcv,
        columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
    )
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df.set_index('timestamp', inplace=True)
    return df

# Get hourly BTC data from Binance
df = get_ohlcv('binance', 'BTC/USDT', '1h', 200)
print(df.tail())

def place_limit_order(exchange, symbol: str, side: str,
                      amount: float, price: float):
    """Place a limit order on any ccxt exchange."""
    try:
        order = exchange.create_order(
            symbol=symbol,
            type='limit',
            side=side,
            amount=amount,
            price=price
        )
        print(f"Order placed on {exchange.id}: "
              f"{side} {amount} {symbol} @ {price}")
        return order
    except ccxt.InsufficientFunds:
        print("Insufficient funds")
    except ccxt.InvalidOrder as e:
        print(f"Invalid order: {e}")
    except ccxt.ExchangeError as e:
        print(f"Exchange error: {e}")
    return None

def get_balances(exchange) -> dict:
    """Get non-zero balances from any exchange."""
    balance = exchange.fetch_balance()
    return {
        currency: {
            'free': info['free'],
            'used': info['used'],
            'total': info['total'],
        }
        for currency, info in balance['total'].items()
        if info and float(info) > 0
    }

async def compare_prices(symbol: str):
    """Compare prices across major exchanges."""
    import ccxt.async_support as ccxt_async

    exchanges = ['binance', 'coinbasepro', 'kraken', 'okx']
    results = {}

    async def fetch_one(eid):
        ex = getattr(ccxt_async, eid)({'enableRateLimit': True})
        try:
            ticker = await ex.fetch_ticker(symbol)
            results[eid] = ticker['last']
        except:
            pass
        finally:
            await ex.close()

    await asyncio.gather(*[fetch_one(e) for e in exchanges])

    for eid, price in sorted(results.items(), key=lambda x: x[1]):
        print(f"{eid:15} ${price:,.2f}")

    if len(results) >= 2:
        prices = list(results.values())
        spread = (max(prices) - min(prices)) / min(prices) * 100
        print(f"Max spread: {spread:.4f}%")