ccxt_client - Elixir client for 110+ cryptocurrency exchanges

Your Libraries & OS Mentoring Libraries
1

ccxt_client is a pure Elixir client for interacting with 110+ cryptocurrency exchanges through a unified API.
It is generated from the CCXT exchange specifications and requires no Node.js at runtime — just Elixir.

{:ccxt_client, "~> 0.1"}

Overview

The library provides a consistent, type-safe interface for both public market data and authenticated trading
operations across a large number of exchanges.

All exchange modules are generated at compile time from specifications extracted from the
CCXT project’s 7+ years of accumulated exchange knowledge.

Usage examples

Public endpoints (works on all exchanges)

{:ok, ticker} = CCXT.Binance.fetch_ticker("BTC/USDT")
{:ok, book} = CCXT.Kraken.fetch_order_book("ETH/USD")

Authenticated endpoints (trading, balances, etc.)

creds = CCXT.Credentials.new(api_key: "...", secret: "...")
{:ok, balance} = CCXT.Bybit.fetch_balance(creds)

{:ok, order} =
  CCXT.OKX.create_order(
    "BTC/USDT",
    "limit",
    "buy",
    0.001,
    50_000.0,
    creds
  )

How it works

Instead of hand-writing and maintaining 110+ exchange modules, ccxt_client is generated using a small set of
reusable patterns:

  1. Exchange specifications (endpoints, signing patterns, symbol formats, capabilities) are extracted from CCXT
  2. Exchange modules are generated via macros at compile time
  3. Requests are signed using 7 parameterized signing patterns that cover 95%+ of exchanges

This approach produces a large exchange surface area with minimal duplication and consistent behavior.

Features

  • Unified API across 110+ exchanges
  • Public endpoints: tickers, order books, trades, OHLCV
  • Authenticated endpoints: balances, orders, trading
  • Type-safe response structs
  • WebSocket support with automatic reconnection
  • Circuit breakers and rate limiting
  • Bidirectional symbol normalization (BTC/USDT ↔ BTCUSDT)
  • All exchanges compile and pass unit tests

Authenticated endpoints have been verified with real credentials on Deribit, Bybit, and a few other exchanges.

Where help is needed

While the signing implementations follow each exchange’s specification, many exchanges have not yet been tested
with real API credentials.

Community testing would be extremely valuable.

If you have an account on any exchange:

  1. Try a public endpoint:

    CCXT.YourExchange.fetch_ticker("BTC/USDT")

  2. Try an authenticated endpoint using testnet or sandbox credentials

  3. Report results (what worked / what didn’t) via GitHub issues

Every tested exchange improves the library for everyone.

Selective compilation

If you do not need all exchanges, you can limit which ones are compiled:

config :ccxt_client, exchanges: [:binance, :bybit, :okx]

Status

This is version v0.1.0 — early, but functional.
Feedback, issues, and pull requests are welcome.

Links

5 Likes
2

v0.2.0 released — WebSocket adapters, telemetry, and a breaking change

Quick update on ccxt_client. v0.2.0 is out with some significant improvements and one breaking change.

:warning: Breaking: Trading modules removed

CCXT.Trading.* modules (Greeks, Funding, Risk, Volatility, Options, etc.) have been extracted to a separate library. If you were using any of those modules, they’re no longer in ccxt_client.

ccxt_client is now a focused exchange-access library — HTTP, WebSocket, signing, symbol normalization, and types only. No changes to any exchange API functionality.

{:ccxt_client, "~> 0.2"}

What’s new

WebSocket Adapter

A managed GenServer that handles reconnection, subscription restoration, and auth state automatically:

{:ok, adapter} =
  CCXT.Bybit.WS.Adapter.start_link(
    url_path: [:public, :spot],
    handler: fn msg -> process_message(msg) end
  )

{:ok, sub} = CCXT.Bybit.WS.watch_ticker_subscription("BTC/USDT")
:ok = CCXT.Bybit.WS.Adapter.subscribe(adapter, sub)

The adapter:

  • Reconnects with exponential backoff
  • Re-subscribes to all active channels after reconnect
  • Handles auth re-authentication with state tracking
    (:unauthenticated → :authenticated → :expired)

The low-level CCXT.WS.Client is still available for short-lived connections where you manage lifecycle yourself.

Telemetry

Centralized event contract with attach/2 and detach/1 support:

CCXT.Telemetry.attach(:my_handler, fn event, measurements, metadata ->
  Logger.info("#{metadata.exchange} #{event}: #{measurements.duration}ms")
end)

Six events covering:

  • HTTP requests
  • WebSocket messages
  • Rate limiting
  • Circuit breaker state changes

Market Precision Metadata

Extract precision info from any exchange’s markets:

{:ok, markets} = CCXT.Binance.fetch_markets()
precisions = CCXT.MarketPrecision.from_markets(markets, :binance)
# => %{"BTC/USDT" => %CCXT.MarketPrecision{price: 2, amount: 5, ...}}

Handles all three CCXT precision modes:

  • Tick size
  • Decimals
  • Significant digits

Includes a TradingView-compatible price format helper.

Other improvements

  • Updated rate limit costs across all 10 Tier 1 exchange specs from upstream CCXT
  • Generator improvements: decoupled coercer/parser pipeline, version-override path prefix handling
  • Deribit bug fixes:
    • fetch_trades/1 arity
    • WS balance channel
    • WS ticker interval suffix

Still looking for testers

The ask from the original post still stands — if you have an account on any exchange, trying even a single endpoint and reporting what happens is enormously helpful:

CCXT.YourExchange.fetch_ticker("BTC/USDT")

Open an issue with what worked and what didn’t.