CCXT vs the HollaEx API

HollaEx is two things at once, and that is the interesting part. It is an exchange at hollaex.com, and it is HollaEx Kit — white-label exchange software that other operators run under their own brand. Every Kit exchange exposes the same /v2 REST API and the same WebSocket stream; only the host changes. HollaEx's own Node library makes that explicit by taking apiURL and wsURL as constructor arguments, defaulting to https://api.hollaex.com and wss://api.hollaex.com/stream.

That shapes the comparison. The question is not only "CCXT or the vendor library" but "which one covers the language you write in, and can it be pointed at the Kit exchange you actually trade on?"

TL;DR

• Pick hollaex-node-lib if you work in Node, want method names that match HollaEx's API guide exactly, and need the admin-tier endpoints an exchange operator uses.
• Pick CCXT if you write in anything other than JavaScript — HollaEx's Python library repository is archived, and there is no maintained PHP, C#, Go or Java client — or if HollaEx is one venue among several.
• Both can be pointed at any HollaEx Kit exchange. The vendor library takes apiURL/wsURL; CCXT's constructor deep-extends urls, so you override the same two values.

At a glance

_{Figures verified September 2026 against CCXT v4.5.77, the hollaex/hollaex-node-lib repository and HollaEx's published API guide, with install counts from npm and PyPI.}

The same job, written both ways

Fetch a ticker

import ccxt from 'ccxt';

const exchange = new ccxt.hollaex ();
const ticker = await exchange.fetchTicker ('BTC/USDT');
console.log (ticker['last'], ticker['baseVolume']);

CCXT returns a unified ticker structure — the same keys, types and units it returns for Kraken or Binance. The vendor library returns HollaEx's payload, and its symbol format (xht-usdt) is HollaEx's own.

Place a limit order

import ccxt from 'ccxt';

const exchange = new ccxt.hollaex ({ apiKey: '...', secret: '...' });
const order = await exchange.createOrder ('XHT/USDT', 'limit', 'buy', 0.1, 1);
console.log (order['id'], order['status']);

Same call, different vocabulary: size versus a unified amount argument, and opts.meta.post_only versus CCXT's unified params: {'postOnly': true} which means the same thing on every venue that supports it.

Where the differences actually bite

Seven languages, one API

This is the decisive difference for HollaEx specifically. The maintained vendor client is Node-only, and the Python library repository was archived by its owner in September 2025. If you write Python, PHP, C#, Go or Java, CCXT is the maintained option — written once in TypeScript and transpiled to all of them with identical method names and return structures.

import ccxt
exchange = ccxt.hollaex()
ticker = exchange.fetch_ticker('BTC/USDT')

Pointing CCXT at another Kit exchange

CCXT's hollaex class is configured for api.hollaex.com, but the constructor deep-extends urls, so the same class drives any HollaEx Kit venue — the API path structure (the host, then /v2/, then the endpoint) and the api-key / api-expires / api-signature header signing are identical across Kit exchanges:

import ccxt

exchange = ccxt.hollaex({
    'apiKey': '...',
    'secret': '...',
    'urls': {'api': {'rest': 'https://api.example-kit-exchange.com'}},
})
markets = exchange.load_markets()

For streaming, override urls['api']['ws'] on ccxt.pro.hollaex the same way. This is the same knob the official Node library exposes as apiURL and wsURL. Call load_markets() and read symbols from it rather than assuming a pair exists — every Kit operator lists their own assets.

WebSockets that look like REST

CCXT Pro — bundled in the same ccxt package, no separate purchase — gives HollaEx 4 streaming methods: watchOrderBook, watchTrades, watchOrders and watchBalance.

import ccxt.pro
import asyncio

async def main():
    exchange = ccxt.pro.hollaex()
    while True:
        orderbook = await exchange.watch_order_book('BTC/USDT')
        print(orderbook['bids'][0], orderbook['asks'][0])

asyncio.run(main())

watch_order_book returns the same structure as fetch_order_book, so swapping a polling loop for a stream is a one-word change and nothing downstream moves. CCXT handles the connection pooling, ping/pong keep-alive, reconnect-and-resubscribe, the snapshot-plus-delta merge and the bounded cache. The vendor library also reconnects automatically — this is one place where both sides do the work — but it hands you HollaEx-shaped messages through callbacks rather than a merged book you await.

Rate limits you do not have to model

CCXT sets rateLimit = 250 ms for HollaEx — four requests per second — and the token-bucket throttler is on by default (enableRateLimit = true). You call methods in a loop and the library paces them, and a rate-limit response is raised as RateLimitExceeded rather than a bare HTTP error.

Precision, rounding and string math

HollaEx uses tick-size precision. CCXT loads that metadata and gives you amount_to_precision, price_to_precision and cost_to_precision, backed by the Precise string-arithmetic class so quantities do not drift through float rounding — the failure mode where a rounding artefact costs you a rejected order.

One error hierarchy

CCXT maps HollaEx's responses onto a typed exception tree — InsufficientFunds, InvalidOrder, OrderNotFound, AuthenticationError, BadRequest, NetworkError and 35 more, all under BaseError. HollaEx returns different failures under the same HTTP code with the detail in a message string; CCXT does the string matching so you catch types.

Sandbox without a second code path

exchange = ccxt.hollaex({'apiKey': '...', 'secret': '...'})
exchange.set_sandbox_mode(True)   # swaps in api.sandbox.hollaex.com

One flag swaps both the REST host and the WebSocket host (wss://api.sandbox.hollaex.com/stream).

Nothing is hidden — the implicit API

Alongside the 40 unified capabilities, all 29 endpoints in CCXT's HollaEx api block are generated as callable implicit methods, camelCased from their paths:

health = exchange.public_get_health()
tiers = exchange.public_get_tiers()
kit = exchange.public_get_kit()

Signing, rate-limit accounting and error mapping still apply. Browse them on the HollaEx implicit API page.

What hollaex-node-lib does better

An honest list, because these are real:

• Admin-tier endpoints. HollaEx's API has an operator side — user management, onboarding, kit configuration — that only makes sense if you run a Kit exchange rather than trade on one. The Node library documents those; CCXT deliberately models the trader-facing API only.
• It is designed to be repointed. apiURL, wsURL and baseURL are first-class constructor options because pointing at an arbitrary Kit exchange is the library's normal case, not an override. In CCXT it works, but it is a urls override rather than a documented product feature.
• HollaEx's own vocabulary. getTicker, createOrder({ symbol, side, size, type, price, opts }) and the xht-usdt symbol format read straight off HollaEx's API guide. CCXT's unified naming is one hop away from the vendor docs.
• The surrounding tooling is in the same ecosystem. hollaex-cli and the plugin starter are built around the same conventions, so an operator running a Kit exchange is already in that world.

If you run a HollaEx Kit exchange, work in Node, and need the admin endpoints, the vendor library is the better fit.

Migrating from hollaex-node-lib to CCXT

FAQ

Is there an official HollaEx Python library? Not a maintained one. HollaEx's Python library repository, hollaex-py-lib-old, was archived by its owner in September 2025 and is read-only. The maintained vendor client is hollaex-node-lib for Node.js. For Python — and for PHP, C#, Go and Java — CCXT is the maintained option, and HollaEx's own API guide lists CCXT as the multi-language route.

Can I use CCXT with a white-label exchange built on HollaEx Kit? Yes. Kit exchanges share the same /v2 API surface and signing scheme, so construct ccxt.hollaex with a urls override pointing api.rest (and api.ws on ccxt.pro.hollaex) at that exchange's hosts. Then call load_markets() — each operator lists their own assets.

Does CCXT support HollaEx futures or margin? No, and neither does the venue through this API. HollaEx is spot-only in CCXT (has.swap and has.future are false), with 40 unified capabilities across market data, trading, balances, deposits and withdrawals.

How do I use the HollaEx sandbox with CCXT? Call exchange.set_sandbox_mode(True), which swaps the REST host to api.sandbox.hollaex.com and the WebSocket host to wss://api.sandbox.hollaex.com/stream.

Do I need CCXT Pro separately for WebSockets? No. CCXT Pro is included in the ccxt package. Use ccxt.pro.hollaex and call watch* methods.

Is CCXT free? Yes. MIT-licensed, including the WebSocket support.

Next steps

• Install CCXT in your language
• Manual — the unified API, structures and conventions
• hollaex unified API reference
• hollaex implicit API — every raw endpoint
• CCXT Pro manual — WebSocket methods
• More comparisons