git clone https://github.com/ccxt/ccxt.git  # including 1GB of commit history

# or

git clone https://github.com/ccxt/ccxt.git --depth 1  # avoid downloading 1GB of commit history

npm install ccxt

//cjs
var ccxt = require ('ccxt')
console.log (ccxt.exchanges) // print all available exchanges

//esm
import {version, exchanges} from 'ccxt';
console.log(version, Object.keys(exchanges));

<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.5.78/dist/ccxt.browser.min.js"></script>

console.log (ccxt.exchanges) // print all available exchanges

pip install ccxt

import ccxt
print(ccxt.exchanges) # print a list of all available exchange classes

import ccxt.async_support as ccxt # link against the asynchronous version of ccxt

pip install coincurve

include "ccxt.php";
var_dump (\ccxt\Exchange::$exchanges); // print a list of all available exchange classes

using ccxt;
Console.WriteLine(ccxt.Exchanges) // check this later

go install github.com/ccxt/ccxt/go/v4@latest

import "ccxt"
fmt.Println(ccxt.Exchanges)

dependencies {
    implementation("io.github.ccxt:ccxt:4.5.52")
}

git clone https://github.com/ccxt/ccxt.git --depth 1
cd ccxt/java
./gradlew :lib:build

import io.github.ccxt.exchanges.Binance;
import io.github.ccxt.types.Ticker;

Binance exchange = new Binance();
exchange.loadMarkets(false);

Ticker ticker = exchange.fetchTicker("BTC/USDT");
System.out.println(ticker.symbol + " " + ticker.last);

// Sync — blocks until the response arrives
Ticker ticker = exchange.fetchTicker("BTC/USDT");

// Async — returns immediately, completes when the response arrives
CompletableFuture<Ticker> future = exchange.fetchTickerAsync("BTC/USDT", null);
future.thenAccept(t -> System.out.println(t.last));

import io.github.ccxt.exchanges.pro.Binance;

var exchange = new Binance();
exchange.loadMarkets(false);

// Sync — blocks for one update
Ticker tick = exchange.watchTicker("BTC/USDT");

// Async — returns a typed CompletableFuture (composable with allOf, anyOf, etc.)
CompletableFuture<Ticker> future = exchange.watchTickerAsync("BTC/USDT", null);

cargo add ccxt tokio --features tokio/full
cargo add ccxt-pro

[dependencies]
ccxt = "4.5.75"
ccxt-pro = "4.5.75"
tokio = { version = "1", features = ["full"] }

use ccxt::{Binance, Params};

let mut exchange = Binance::new(None);
exchange.load_markets(false).await;

let ticker = exchange.fetch_ticker("BTC/USDT", Params::none()).await?;
println!("{} {:?}", ticker.symbol, ticker.last);

docker-compose run --rm ccxt

npx skills add ccxt/ccxt

// both of these notations work in JavaScript/Python/PHP
exchange.methodName ()  // camelcase pseudocode
exchange.method_name () // underscore pseudocode

// cjs example
'use strict';
const ccxt = require ('ccxt');

(async function () {
    let kraken    = new ccxt.kraken ()
    let bitfinex  = new ccxt.bitfinex ({ verbose: true })
    let huobipro  = new ccxt.huobipro ()
    let okcoinusd = new ccxt.okcoin ({
        apiKey: 'YOUR_PUBLIC_API_KEY',
        secret: 'YOUR_SECRET_PRIVATE_KEY',
    })

    const exchangeId = 'binance'
        , exchangeClass = ccxt[exchangeId]
        , exchange = new exchangeClass ({
            'apiKey': 'YOUR_API_KEY',
            'secret': 'YOUR_SECRET',
        })

    console.log (kraken.id,    await kraken.loadMarkets ())
    console.log (bitfinex.id,  await bitfinex.loadMarkets  ())
    console.log (huobipro.id,  await huobipro.loadMarkets ())

    console.log (kraken.id,    await kraken.fetchOrderBook (kraken.symbols[0]))
    console.log (bitfinex.id,  await bitfinex.fetchTicker ('BTC/USD'))
    console.log (huobipro.id,  await huobipro.fetchTrades ('ETH/USDT'))

    console.log (okcoinusd.id, await okcoinusd.fetchBalance ())

    // sell 1 BTC/USD for market price, sell a bitcoin for dollars immediately
    console.log (okcoinusd.id, await okcoinusd.createMarketSellOrder ('BTC/USD', 1))

    // buy 1 BTC/USD for $2500, you pay $2500 and receive ฿1 when the order is closed
    console.log (okcoinusd.id, await okcoinusd.createLimitBuyOrder ('BTC/USD', 1, 2500.00))

    // pass/redefine custom exchange-specific order params: type, amount, price or whatever
    // use a custom order type
    bitfinex.createLimitSellOrder ('BTC/USD', 1, 10, { 'type': 'trailing-stop' })

}) ();

//esm example
import {version, binance} from 'ccxt';

console.log(version);
const exchange = new binance();
const ticker = await exchange.fetchTicker('BTC/USDT');
console.log(ticker);

# coding=utf-8

import ccxt

hitbtc   = ccxt.hitbtc({'verbose': True})
bitmex   = ccxt.bitmex()
huobipro = ccxt.huobipro()
exmo     = ccxt.exmo({
    'apiKey': 'YOUR_PUBLIC_API_KEY',
    'secret': 'YOUR_SECRET_PRIVATE_KEY',
})
kraken = ccxt.kraken({
    'apiKey': 'YOUR_PUBLIC_API_KEY',
    'secret': 'YOUR_SECRET_PRIVATE_KEY',
})

exchange_id = 'binance'
exchange_class = getattr(ccxt, exchange_id)
exchange = exchange_class({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET',
})

hitbtc_markets = hitbtc.load_markets()

print(hitbtc.id, hitbtc_markets)
print(bitmex.id, bitmex.load_markets())
print(huobipro.id, huobipro.load_markets())

print(hitbtc.fetch_order_book(hitbtc.symbols[0]))
print(bitmex.fetch_ticker('BTC/USD'))
print(huobipro.fetch_trades('LTC/USDT'))

print(exmo.fetch_balance())

# sell one ฿ for market price and receive $ right now
print(exmo.id, exmo.create_market_sell_order('BTC/USD', 1))

# limit buy BTC/EUR, you pay €2500 and receive ฿1  when the order is closed
print(exmo.id, exmo.create_limit_buy_order('BTC/EUR', 1, 2500.00))

# pass/redefine custom exchange-specific order params: type, amount, price, flags, etc...
kraken.create_market_buy_order('BTC/USD', 1, {'trading_agreement': 'agree'})

include 'ccxt.php';

$poloniex = new \ccxt\poloniex ();
$bittrex  = new \ccxt\bittrex  (array ('verbose' => true));
$quoinex  = new \ccxt\quoinex   ();
$zaif     = new \ccxt\zaif     (array (
    'apiKey' => 'YOUR_PUBLIC_API_KEY',
    'secret' => 'YOUR_SECRET_PRIVATE_KEY',
));
$hitbtc   = new \ccxt\hitbtc   (array (
    'apiKey' => 'YOUR_PUBLIC_API_KEY',
    'secret' => 'YOUR_SECRET_PRIVATE_KEY',
));

$exchange_id = 'binance';
$exchange_class = "\\ccxt\\$exchange_id";
$exchange = new $exchange_class (array (
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET',
));

$poloniex_markets = $poloniex->load_markets ();

var_dump ($poloniex_markets);
var_dump ($bittrex->load_markets ());
var_dump ($quoinex->load_markets ());

var_dump ($poloniex->fetch_order_book ($poloniex->symbols[0]));
var_dump ($bittrex->fetch_trades ('BTC/USD'));
var_dump ($quoinex->fetch_ticker ('ETH/EUR'));
var_dump ($zaif->fetch_ticker ('BTC/JPY'));

var_dump ($zaif->fetch_balance ());

// sell 1 BTC/JPY for market price, you pay ¥ and receive ฿ immediately
var_dump ($zaif->id, $zaif->create_market_sell_order ('BTC/JPY', 1));

// buy BTC/JPY, you receive ฿1 for ¥285000 when the order closes
var_dump ($zaif->id, $zaif->create_limit_buy_order ('BTC/JPY', 1, 285000));

// set a custom user-defined id to your order
$hitbtc->create_order ('BTC/USD', 'limit', 'buy', 1, 3000, array ('clientOrderId' => '123'));

using ccxt; // importing ccxt
namespace Project;
class Project {
    public async static Task CreateOrder() {
        var exchange = new Binance();
        exchange.apiKey = "my api key";
        exchange.secret = "my secret";
        // always use the capitalized method (CreateOrder instead of createOrder)
        var order = await exchange.CreateOrder("BTC/USDT", "limit", "buy", 1, 50);
        Console.WriteLine("Placed Order, order id: " + order.id);
    }
}

package main
import (
	"github.com/ccxt/ccxt/go/v4/go"
	"fmt"
)

func main() {
	exchange := ccxt.NewBinance(map[string]interface{}{
		"apiKey": "MY KEY",
		"secret": "MY SECRET",
	})
	orderParams := map[string]interface{}{
		"clientOrderId": "myOrderId68768678",
	}

    exchange.LoadMarkets()

	order, err := exchange.CreateOrder("BTC/USDT", "limit", "buy", 0.001, ccxt.WithCreateOrderPrice(6000), ccxt.WithCreateOrderParams(orderParams))
	if err != nil {
		if ccxtError, ok := err.(*ccxt.Error); ok {
			if ccxtError.Type == "InvalidOrder" {
				fmt.Println("Invalid order")
			} else {
				fmt.Println("Some other error")
			}
		}
	} else {
		fmt.Println(*order.Id)
	}


    // fetching OHLCV
	ohlcv, err := exchange.FetchOHLCV("BTC/USDT", ccxt.WithFetchOHLCVTimeframe("5m"), ccxt.WithFetchOHLCVLimit(100))

	if err != nil {
		fmt.Println("Error: ", err)
	} else {
		fmt.Println("Got OHLCV!")
	}
}

func (this *Binance) FetchMyTrades(options ...FetchMyTradesOptions) ([]Trade, error)

trades, error := exchange.FetchMyTrades(ccxt.withFetchMyTradesSymbol("BTC/USDT"), ccxt.WithFetchOHLCVLimit(5), ccxt.WithFetchMyTradesParams(orderParams))

import io.github.ccxt.exchanges.Kraken;
import io.github.ccxt.exchanges.Bitfinex;
import io.github.ccxt.exchanges.Binance;
import io.github.ccxt.types.*;

import java.util.HashMap;
import java.util.Map;

public class Example {
    public static void main(String[] args) {
        // Create exchange instances
        Kraken kraken = new Kraken();
        Bitfinex bitfinex = new Bitfinex();

        Map<String, Object> config = new HashMap<>();
        config.put("apiKey", "YOUR_API_KEY");
        config.put("secret", "YOUR_SECRET");
        Binance binance = new Binance(config);

        // Load markets
        kraken.loadMarkets(false);
        binance.loadMarkets(false);

        // Public API
        OrderBook orderBook = kraken.fetchOrderBook("BTC/USDT");
        Ticker ticker = bitfinex.fetchTicker("BTC/USD");
        System.out.println(ticker.symbol + " last=" + ticker.last);

        // Fetch OHLCV
        var candles = binance.fetchOHLCV("BTC/USDT", "1h", null, 10L, null);
        System.out.println("Got " + candles.size() + " candles");

        // Private API (requires API keys)
        Balances balance = binance.fetchBalance();
        System.out.println("BTC free: " + balance.free.get("BTC"));

        // Place a limit buy order
        Order order = binance.createLimitBuyOrder("BTC/USDT", 0.001, 50000.0);
        System.out.println("Order id: " + order.id + " status: " + order.status);

        // Cancel it
        binance.cancelOrder(order.id, "BTC/USDT", null);
    }
}

import java.util.concurrent.CompletableFuture;

// Fire multiple requests concurrently
CompletableFuture<Ticker> btc = binance.fetchTickerAsync("BTC/USDT", null);
CompletableFuture<Ticker> eth = binance.fetchTickerAsync("ETH/USDT", null);
CompletableFuture.allOf(btc, eth).join();
System.out.println("BTC: " + btc.get().last + " ETH: " + eth.get().last);

import io.github.ccxt.errors.*;
import io.github.ccxt.exchanges.Binance;
import io.github.ccxt.types.Order;

Binance binance = new Binance(Map.of("apiKey", "...", "secret", "..."));
try {
    Order order = binance.createOrder("BTC/USDT", "limit", "buy", 0.001, 50000.0);
} catch (InsufficientFunds e) {
    // user error — show balance, don't retry
} catch (InvalidOrder e) {                        // covers OrderNotFound, DuplicateOrderId, …
    // user error — fix params
} catch (AuthenticationError e) {                 // covers PermissionDenied, AccountSuspended
    // refresh credentials
} catch (RateLimitExceeded | DDoSProtection e) {  // multi-catch (Java 7+)
    Thread.sleep(30_000);
} catch (NetworkError e) {                        // RequestTimeout, ExchangeNotAvailable, …
    Thread.sleep(2_000);                          // transient — retry
} catch (ExchangeError e) {                       // any other exchange-side error
    // exchange refused
} catch (BaseError e) {                           // ccxt catch-all
    // unknown ccxt error
}

import io.github.ccxt.Helpers;

binance.createOrderAsync("BTC/USDT", "limit", "buy", 0.001, 50000.0)
    .thenAccept(order -> log.info("placed " + order.id))
    .exceptionally(throwable -> {
        Throwable cause = Helpers.unwrap(throwable);
        return switch (cause) {
            case InsufficientFunds    e -> { notifyUser(e); yield null; }
            case AuthenticationError  e -> { refreshCreds(); yield null; }
            case RateLimitExceeded    e -> { scheduleRetry(); yield null; }
            case NetworkError         e -> { scheduleRetry(); yield null; }
            case BaseError            e -> { log.error("ccxt", e); yield null; }
            default -> throw new java.util.concurrent.CompletionException(cause);
        };
    });

import io.github.ccxt.Exchange;
import io.github.ccxt.exchanges.pro.Binance;

import java.util.concurrent.TimeUnit;

Exchange exchange = new Binance();
exchange.loadMarkets().join();

// stream live ticker updates
for (int i = 0; i < 10; i++) {
    Object ticker = exchange.watchTicker("BTC/USDT").get(30, TimeUnit.SECONDS);
    System.out.println(ticker);
}

use ccxt::{Binance, Config, Params};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut exchange = Binance::with_config(
        Config::new()
            .api_key("MY KEY")
            .secret("MY SECRET"),
    );
    exchange.load_markets(false).await;

    let order = exchange
        .create_order("BTC/USDT", "limit", "buy", 0.001, Some(50000.0), Params::none())
        .await?;
    println!("{:?}", order.id);
    Ok(())
}

use ccxt::{Binance, Config, Params};

let mut exchange = Binance::with_config(
    Config::new()
        .api_key("MY KEY")
        .secret("MY SECRET")
        .sandbox(true)
        .enable_rate_limit(true)
        .option_str("defaultType", "swap")
        .option("fetchMarkets", Params::new().with_strs("types", &["spot", "linear"])),
);

let order = exchange
    .create_order(
        "BTC/USDT",
        "limit",
        "buy",
        0.001,
        Some(50000.0),
        Params::new()
            .with_str("clientOrderId", "myOrderId68768678")
            .with_bool("postOnly", true)
            .with_str("timeInForce", "GTC"),
    )
    .await?;

exchange.set_verbose(true);
exchange.set_sandbox_mode(true);

let market = exchange.market("BTC/USDT")?;
println!("{} {}", market.symbol, market.market_type);
println!("{:?} {:?}", market.limits.amount.min, market.limits.cost.min);
println!("{:?}", market.precision.amount);

let swaps: Vec<_> = exchange.markets().into_iter().filter(|m| m.swap && m.active).collect();
println!("{}", swaps.len());

match exchange.create_order("BTC/USDT", "limit", "buy", 0.001, Some(50000.0), Params::none()).await {
    Ok(order) => println!("{:?}", order.id),
    Err(e) if e.is("InsufficientFunds") => println!("not enough balance"),
    Err(e) if e.is("InvalidOrder") => println!("bad parameters: {}", e.message),
    Err(e) if e.is("AuthenticationError") => println!("check credentials"),
    Err(e) if e.is("RateLimitExceeded") => tokio::time::sleep(Duration::from_secs(30)).await,
    Err(e) if e.is("NetworkError") => tokio::time::sleep(Duration::from_secs(2)).await,
    Err(e) => println!("{} {}", e.kind, e.message),
}

use ccxt::{from_id_with_config, Config, Params, TypedExchangeExt};

for id in ["binance", "bybit", "okx"] {
    let Some(mut exchange) = from_id_with_config(id, Config::new()) else { continue };
    exchange.load_markets(false).await;

    let market = exchange.market("BTC/USDT")?;
    let ticker = exchange.fetch_ticker("BTC/USDT", Params::none()).await?;
    println!("{id} {:?} {:?}", ticker.last, market.limits.cost.min);
}

use ccxt::Params;
use ccxt_pro::Binance;

let mut exchange = Binance::new(None);
exchange.load_markets(false).await;

loop {
    let orderbook = exchange.watch_order_book("BTC/USDT", Some(10), Params::none()).await?;
    println!("{:?} {:?}", orderbook.bids.first(), orderbook.asks.first());
}

let symbols = vec!["BTC/USDT".to_string(), "ETH/USDT".to_string()];
let trades = exchange.watch_trades_for_symbols(symbols, None, None, Params::none()).await?;

exchange = ccxt.binance({
    'rateLimiterAlgorithm': 'rollingWindow', # switching to rolling window algorithm
    'rollingWindowSize': 5000 # if binance allows X requests per 5 seconds, those requests can be fired in a burst at any time during this window
})

npm i ccxt-cli -g

ccxt binance createOrder BTC/USDT market buy 0.1 // places an order

ccxt explain createOrder

Method: createOrder
Usage:
  binance createOrder <symbol> <type> <side> <amount> [price] [params]

Arguments:
  - symbol       (required) — Market symbol e.g., BTC/USDT
  - type         (required) — (no description available)
  - side         (required) — order side e.g., buy or sell
  - amount       (required) — (no description available)
  - price        (optional) — Price per unit of asset e.g., 26000.50
  - params       (optional) — Extra parameters for the exchange e.g., { "recvWindow": 5000 }

claude mcp add ccxt -- npx -y ccxt-mcp

{ "mcpServers": { "ccxt": { "command": "npx", "args": ["-y", "ccxt-mcp"] } } }