CC

ccxt-typescript

A guide and integration tool for using the CCXT library in TypeScript/JavaScript to build crypto trading tools.

Install

mkdir -p .claude/skills/ccxt-typescript && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/3418" && unzip -o skill.zip -d .claude/skills/ccxt-typescript && rm skill.zip

Installs to .claude/skills/ccxt-typescript

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

CCXT cryptocurrency exchange library for TypeScript and JavaScript developers (Node.js and browser). Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors. Use when working with crypto exchanges in TypeScript/JavaScript projects, trading bots, arbitrage systems, or portfolio management tools. Includes both REST and WebSocket examples.
493 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Beginner

Key capabilities

  • →Facilitates REST API initialization for Node.js or browser clients
  • →Enables live WebSocket price feed subscription via ccxt.pro
  • →Standardizes market data fetching syntax across different exchanges
  • →Manages authentication and exchange connectivity workflows

How it works

Abstracts varied exchange API protocols into a consistent JavaScript/TypeScript class interface using a uniform naming convention.

Inputs & outputs

You give it
Exchange name and requested market data symbol
You get back
Formatted ticker, orderbook, or account trade data

When to use ccxt-typescript

  • →Building JS trading bots
  • →Real-time ticker monitoring
  • →Arbitrage system development
  • →Portfolio management

About this skill

CCXT for TypeScript/JavaScript

A comprehensive guide to using CCXT in TypeScript and JavaScript projects for cryptocurrency exchange integration.

Installation

REST API (Standard CCXT)

npm install ccxt

WebSocket API (Real-time, ccxt.pro)

npm install ccxt

Both REST and WebSocket APIs are included in the same package.

Quick Start

REST API - TypeScript

import ccxt from 'ccxt'

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

REST API - JavaScript (CommonJS)

const ccxt = require('ccxt')

(async () => {
    const exchange = new ccxt.binance()
    await exchange.loadMarkets()
    const ticker = await exchange.fetchTicker('BTC/USDT')
    console.log(ticker)
})()

WebSocket API - Real-time Updates

import ccxt from 'ccxt'

const exchange = new ccxt.pro.binance()
while (true) {
    const ticker = await exchange.watchTicker('BTC/USDT')
    console.log(ticker)  // Live updates!
}
await exchange.close()

REST vs WebSocket

FeatureREST APIWebSocket API
Use forOne-time queries, placing ordersReal-time monitoring, live price feeds
Method prefixfetch* (fetchTicker, fetchOrderBook)watch* (watchTicker, watchOrderBook)
SpeedSlower (HTTP request/response)Faster (persistent connection)
Rate limitsStrict (1-2 req/sec)More lenient (continuous stream)
Importccxt.exchange()ccxt.pro.exchange()
Best forTrading, account managementPrice monitoring, arbitrage detection

When to use REST:

  • Placing orders
  • Fetching account balance
  • One-time data queries
  • Order management (cancel, fetch orders)

When to use WebSocket:

  • Real-time price monitoring
  • Live orderbook updates
  • Arbitrage detection
  • Portfolio tracking with live updates

Creating Exchange Instance

REST API

// Public API (no authentication)
const exchange = new ccxt.binance({
    enableRateLimit: true  // Recommended!
})

// Private API (with authentication)
const exchange = new ccxt.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET',
    enableRateLimit: true
})

WebSocket API

// Public WebSocket
const exchange = new ccxt.pro.binance()

// Private WebSocket (with authentication)
const exchange = new ccxt.pro.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET'
})

// Always close when done
await exchange.close()

Common REST Operations

Loading Markets

// Load all available trading pairs
await exchange.loadMarkets()

// Access market information
const btcMarket = exchange.market('BTC/USDT')
console.log(btcMarket.limits.amount.min)  // Minimum order amount

Fetching Ticker

// Single ticker
const ticker = await exchange.fetchTicker('BTC/USDT')
console.log(ticker.last)      // Last price
console.log(ticker.bid)       // Best bid
console.log(ticker.ask)       // Best ask
console.log(ticker.baseVolume)    // 24h volume in base currency (quoteVolume for quote)

// Multiple tickers (if supported)
const tickers = await exchange.fetchTickers(['BTC/USDT', 'ETH/USDT'])

Fetching Order Book

// Full orderbook
const orderbook = await exchange.fetchOrderBook('BTC/USDT')
console.log(orderbook.bids[0])  // [price, amount]
console.log(orderbook.asks[0])  // [price, amount]

// Limited depth
const orderbook = await exchange.fetchOrderBook('BTC/USDT', 5)  // Top 5 levels

Creating Orders

Limit Order

// Buy limit order
const order = await exchange.createLimitBuyOrder('BTC/USDT', 0.01, 50000)
console.log(order.id)

// Sell limit order
const order = await exchange.createLimitSellOrder('BTC/USDT', 0.01, 60000)

// Generic limit order
const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000)

Market Order

// Buy market order
const order = await exchange.createMarketBuyOrder('BTC/USDT', 0.01)

// Sell market order
const order = await exchange.createMarketSellOrder('BTC/USDT', 0.01)

// Generic market order
const order = await exchange.createOrder('BTC/USDT', 'market', 'sell', 0.01)

Fetching Balance

const balance = await exchange.fetchBalance()
console.log(balance.BTC.free)   // Available balance
console.log(balance.BTC.used)   // Balance in orders
console.log(balance.BTC.total)  // Total balance

Fetching Orders

// Open orders
const openOrders = await exchange.fetchOpenOrders('BTC/USDT')

// Closed orders
const closedOrders = await exchange.fetchClosedOrders('BTC/USDT')

// All orders (open + closed)
const allOrders = await exchange.fetchOrders('BTC/USDT')

// Single order by ID
const order = await exchange.fetchOrder(orderId, 'BTC/USDT')

Fetching Trades

// Recent public trades
const trades = await exchange.fetchTrades('BTC/USDT', undefined, 10)

// Your trades (requires authentication)
const myTrades = await exchange.fetchMyTrades('BTC/USDT')

Canceling Orders

// Cancel single order
await exchange.cancelOrder(orderId, 'BTC/USDT')

// Cancel all orders for a symbol
await exchange.cancelAllOrders('BTC/USDT')

Bitget Stock Routing

Default market discovery cross-references classic spot symbols against public UTA spot instruments to identify stocks; await exchange.loadMarkets() is sufficient. symbolType: 'stock' sets market.stock: true; isReality: 'yes' is a fallback only when symbolType is absent. Stock-underlying derivatives remain derivatives and do not use Reality spot REST endpoints. Stock spot WebSocket subscriptions automatically use UTA; stock-underlying derivatives retain classic derivative WebSockets unless uta: true is selected explicitly. Required-symbol REST methods and supported stock WebSocket subscriptions infer routing from the market and discard legacy params.stock; stock options cannot override that routing. Keep stock selectors for symbol-less discovery, tickers and balances. This does not add Stock+ securities-account support or imply ownership of underlying shares.

Backpack Tokenized Stocks (REST)

  • fetchMarkets accepts scalar or array marketType aliases: spot/SPOT, swap/PERP, stock/RFQ. The stock alias selects RFQs; params.stock: true filters stock underlyings across execution types.
  • Market discovery deduplicates exchange IDs while keeping spot, perpetual and RFQ symbols separate. Restrict marketType to ['SPOT'] or ['PERP'] to avoid the securities request; stock-underlying perpetuals remain swaps, not tokenized spot holdings.
  • fetchCurrencies() uses the assets endpoint only, with .US and .HK symbols classified as type: 'stock'. It returns all assets by default; fetchCurrencies({ stock: true }) returns stocks only. Securities metadata is fetched separately by market discovery for RFQ sessions and limits.
  • Default backpack.loadMarkets() includes security-discovered RFQs (AAPL.US.RFQ/USDC) and available stock spot books (MU.US/USDC). Use the symbols actually returned by the exchange. RFQs have executionModel: 'rfq'; both stock execution paths have stock: true and are not derivatives.
  • Symbol-scoped stock/RFQ methods infer stock status from the market; stock: true is needed for symbol-less stock filters such as balances/currencies, and stock: false explicitly opts out. For provider statistics, source: 'External' is inferred for RFQ symbols; Backpack does not document a separate native stock/ETF ownership account or an equity selector. Do not claim underlying-share ownership.
  • fetchTicker/fetchTickers accept source: 'Venue' | 'External' and interval; market symbols infer stock routing, and RFQ ticker stats default to External (1d). fetchOHLCV accepts the same source, with External requiring priceType: 'Last'. Explicit source/stock params override inference. RFQ-symbol statistics refer to the underlying market, not an executable quote.
  • Exchange-specific fetchSecurities() and fetchStockIndicativeQuote(symbol, 'buy' | 'sell', baseAmount) are public metadata/quote helpers (market sessions/holidays have no unified method; use the implicit publicGetApiV1MarketHolidays endpoint). Indicative price is a limit and estimatedPrice is not guaranteed. Never reinterpret indicative quotes as order-book depth.
  • RFQ createOrder accepts base quantity only and submits Immediate. Limit RFQs preserve the supplied price; market RFQs use a supplied price bound or obtain a stock indicative bound. Stock RFQs check current-session quote availability and size constraints without rounding shares. Fills are not guaranteed. Unified createOrder rejects AwaitAccept because that mode does not accept an engine-enforced price bound. Advanced unpriced RFQs submitted through the implicit API can be explicitly accepted with acceptRfqQuote(rfqId, quoteId, symbol). Acceptance can bind funds before deferred settlement; do not report it as filled prematurely.
  • RFQ symbols route order/open-order history, fetchOrder, cancellation and private fills to RFQ APIs. Without a symbol, stock: true combines stock venue and requester RFQ records; rfq: true restricts to RFQs. RFQ time filtering applies to the retrieved history page (offset, limit, sortDirection), not an automatically paginated history.
  • fetchBalance({ stock: true }) returns tokenized stock assets from the capital account. fetchPositions is derivatives-only. RFQ fetchOrderBook/public fetchTrades, RFQ batches/bulk cancellation, quote-cost amounts, post-only and trigger/bracket orders are unsupported. Cancel RFQs individually. A resting RFQ cancellation request need not immediately change its status to canceled.
  • fetchConvertQuote(fromCode, toCode, amount) is an indicative stock-RFQ estim

Content truncated.

When not to use it

  • →Native non-JS environments or backend languages like C++/Rust
  • →Low-latency environments where JS runtime overhead is unacceptable

Prerequisites

node.jsnpm

Limitations

  • →WebSocket features require ccxt.pro support
  • →Synchronous-style code requires async/await wrappers for all network calls

How it compares

Replaces fragmented, exchange-specific API SDKs with a single, unified client library for all JS environments.

Compared to similar skills

ccxt-typescript side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
ccxt-typescript (this skill)19moReviewBeginner
shopify-apps17moReviewIntermediate
shopify-development129moReviewIntermediate
convex09moNo flagsBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

ccxt-csharp

ccxt

CCXT cryptocurrency exchange library for C# and .NET developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in .NET projects. Use when working with crypto exchanges in C# applications, trading systems, or financial software. Supports .NET Standard 2.0+.

13

ccxt-go

ccxt

CCXT cryptocurrency exchange library for Go developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in Go projects. Use when working with crypto exchanges in Go applications, microservices, or trading systems.

15

ccxt-php

ccxt

CCXT cryptocurrency exchange library for PHP developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in PHP 8.1+. Use when working with crypto exchanges in PHP projects, trading bots, or web applications. Supports both sync and async (ReactPHP) usage.

18

ccxt-python

ccxt

CCXT cryptocurrency exchange library for Python developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in Python. Use when working with crypto exchanges in Python projects, trading bots, data analysis, or portfolio management. Supports both sync and async (asyncio) usage.

16

Search skills

Search the agent skills registry