Real-time market data, in-house AI models, and unified execution across every major exchange — on one authenticated API. The complete finance platform, built on infrastructure we own.
Shadow run on Bitfinex tBTCUST under the venue's zero-fee program · model h1000_w20_200ms.pt · methodology and live logs available on request · past results don't predict future returns.
Dataliser is the complete finance platform — real-time market data, proprietary AI models with a natural-language copilot, and institutional-class execution across every exchange. All on the same authenticated stream, all built on infrastructure we own.
Real-time L2 order books, trades, and derivatives from 30+ exchanges — normalized into a single schema, delivered over one WebSocket. Equinix-colocated ingest, nanosecond timing breadcrumbs, FlatBuffers wire format.
A fleet of neural-network models (LSTM, transformer, DeepLOB) continuously trained on our proprietary pipeline, plus a natural-language copilot that lets your users ask the market questions in plain English and get answers grounded in live data.
EMS + OMS over every exchange through a single authenticated API. Place, cancel, replace. Rate-limit protection built in. Full account state streaming (balances, positions, margin, funding). Bring your own exchange keys.
Most providers give you a JSON dump and call it a day. We ship the firehose, the schema, and the intelligence — so you can spend your time deciding when to click, not building plumbing.
Tick-by-tick L2 order books and trades from 30+ exchanges, streamed over a single WebSocket. 11ms median end-to-end. Spot, futures, perpetuals, options.
Symbology and message shape are unified across every venue. Stop writing connectors. Stop hunting schema drift on Sunday morning. Same payload whether it's Binance perps or Kraken spot.
Four neural-network signal channels — Pulse, Compass, Whales, Forecast — stream alongside the raw data. Subscribe to what you need, ignore what you don't. See the AI section for depth.
A fleet of specialized neural-network models continuously trained on our proprietary pipeline. Plus a finance-tuned language model copilot that reads real-time depth and talks to you in plain English about what it sees.
Real-time liquidity and order-flow imbalance scored 0–100 per symbol per venue. Lights up when one side of the book gets thin or aggressors lean hard.
Short-horizon regime classifier. Tells you whether the market right now is trending, mean-reverting, or chopping — so your strategy knows what room it's in.
Large-order and iceberg detection across venues. Get pinged the moment a real participant shows up in the book — before the chart catches up.
NN-predicted short-horizon price drift — 1, 5, and 15 minute windows. Probability-weighted, calibrated to historical hit rates so you can size bets honestly.
A finance-tuned language model with live access to your Dataliser stream. Natural-language queries. Strategy design. Backtest orchestration. Grounded in real data, not hallucinated out of a web crawl.
In-house fine-tune of open base model. RAG over MDS firehose + historical shadow runs. Function-calling access to our model fleet and backtest harness.
Place, cancel, replace orders across every major exchange through a single authenticated API. Bring your own exchange keys. We handle the rate-limit math, the reconciliation, the account state streaming, and the nanosecond timing — so your bot focuses on alpha, not plumbing.
One API shape for new / cancel / replace across all venues. Normalized acks, rejects, fills, and fee updates. Position-intent enforcement, reduce-only, kill switch — built in.
Two-bucket token limiter per venue with burst buffer. Separates new/replace from cancel budgets so you can always cancel out of a hole. Never ban yourself.
Eight nanosecond timestamps per order — bep emit, EDS ingress, EDS to venue, venue request received, venue acked, exchange event, EDS ingress for fill, publish. Argue with facts, not vibes.
Real-time BalanceUpdate / PositionUpdate / MarginUpdate / FundingUpdate deltas. Settled-truth ground state that pairs with your fast-truth fills. Auto-borrow lifecycle tracked per position.
Venue drops? Your bot loses nothing. Events missed during the blip replay with from_reconcile: true. Snapshot queries on demand.
Live stream for speed, append-only journal for audit. The live socket may drop under HWM; the journal never does. Perfect fill accounting across any failure mode.
{ "client_order_id": 1817349,
"venue": "binance_perp",
"symbol": "BTCUSDT",
"side": "BUY",
"qty": 0.05,
"order_type": "LIMIT",
"price": 68420,
"tif": "GTC",
"position_intent": "OPEN",
"flags": { "post_only": true } }
// → OrderAck · venue_order_id · 8 ts
// → Fill (te) · FillFeeUpdate (tu) · seq
// → PositionUpdate on UDS stream
Every Pulse, Compass, Whales, and Forecast call routes back to one inference layer — a sequence model running inside our colocated stack, trained on years of normalized order-book and trade data. The four signal channels are different views into the same brain.
53 order-book features plus 20 trade-flow features per tick. The OB side runs a 57-feature extractor; 4 raw-price features are excluded as non-stationary. The trade side buckets raw ticks at 200ms and computes flow imbalance, VWAP, plus academic microstructure proxies — Roll spread, Amihud illiquidity, Kyle's lambda. Every feature has a feature name. Nothing is a black box.
| Architecture | 2-layer LSTM |
| Input features | 73 |
| Window size | 20 ticks @ 200ms |
| LSTM dims | 128 hidden · 0.3 dropout |
| Output head | MLP [128, 64] · 0.4 dropout |
| Target | 1s expected return (bps) |
| Day-boundary safe | yes |
| Serving | libtorch JIT · C++ |
| Device | CPU · CUDA · MPS · B300 |
Most retail-facing "AI signals" are accidentally trained across day boundaries — leakage that backtests beautifully and dies in production. Our train/val split is enforced on day boundaries with the day_boundary_safe: true contract baked into the model config. If it isn't, the model doesn't ship.
Every prediction passes through a market-quality score before reaching policy. Wide spread, stale feed, anomalous update rate, or pipeline latency over budget — and the signal is dropped instead of acted on. Configurable per subscriber via qualityFloorScore.
Two architectures run in parallel on the live tape — the LSTM regressor (champion) and a 3-class MLP classifier (challenger). TLOB, DeepLOB, and HLOB variants in queue. The signal you subscribe to comes from whichever is winning the live A/B.
The model spits out an expected return. The policy decides whether that expectation is worth acting on. Each gate can veto the signal (soft) or arm a permanent kill (hard). Every evaluation is logged across 42 columns for offline analysis. The gauntlet is why our signals survive production where most retail "AI signals" die.
73,876 lines of C++17 across 332 source files. None of it stitched together from libraries that happened to be on Stack Overflow. Every layer was a deliberate choice driven by a production failure mode we'd rather not repeat.
Lock-free ring buffers separate execution events (fills, balance updates) from market data (depth, candles, trades). The execution queue is always drained first. Your fills never wait behind a burst of book updates from a noisy venue.
Consumer spins briefly when a new event arrives, then parks on a futex if the queue goes quiet. Sub-microsecond wake latency under load. Zero idle CPU when the market is asleep. Tuned per pipeline stage.
Beyond the LSTM, the analytics layer runs continuous wavelet transforms (Morlet, 6 scales) via FFTW3 for divergence detection — finding spots where price and momentum tell different stories. Plus SMA, RSI, support/resistance, and trendline extraction.
Every order carries 8 nanosecond steady-clock timestamps from bep emit to venue ack to fill publish. Every market data event carries 4. When latency regresses, you don't argue about whose fault it is — you look at the trail and the trail tells you.
The model is descended from the published canon of order-book deep learning — not invented from scratch and not "AI" the marketing word. Active reading list across 6 workstreams, refreshed quarterly. A sample of what's currently informing the stack:
The hot path never touches a public cloud. We own the AI data center in Dubai where models are trained and served. We cross-connect at Equinix next to every major exchange where market data is ingested and orders are routed. The stack from silicon to API is ours.
Owned facility — not colocation. NVIDIA HGX B300 (8× Blackwell Ultra per node) for AI training, inference, and research. Mixed-use capacity: internal model fleet, LLM copilot serving, DRL simulation environments.
Cross-connect in every exchange's home campus. Dataliser hardware physically next to the matching engine so your market data arrives in microseconds and your orders travel the shortest possible path.
MDS, EDS, and UDS are the internal server processes behind the three customer-facing product lines. They scale and restart independently. Same handshake, same timing discipline, same lossless journal pattern.
Real-time exchange depth, fanned out at line rate.
powers → Dataliser Data · feeds AI{ "action": "subscribe",
"service": "mds",
"venue": "binance",
"symbol": "BTCUSDT",
"stream": "book" }
// → topic: BTCUSDT.book
// → payload: DepthTick (binary)
// → timing: 4 × uint64 checkpoints
Place, cancel, replace — with rate limits and risk gates already wired.
powers → Dataliser Executefrom_reconcile: true.{ "action": "new_order",
"client_order_id": 1817349,
"venue": "binance_perp",
"symbol": "BTCUSDT",
"side": "BUY",
"qty": 0.05,
"order_type": "LIMIT",
"price": 68420,
"position_intent": "OPEN" }
Balances, positions, margin, funding — streamed and queryable.
powers → Dataliser ExecuteBalanceUpdate, PositionUpdate, MarginUpdate, FundingUpdate.list_positions, list_balances, list_funding.// event: PositionUpdate { "venue": "binance_perp", "symbol": "BTCUSDT", "qty": 0.042, "avg_entry_px": 68411.20, "liquidation_px": 65120.50, "unrealized_pnl_usdt": +2.84, "margin_used_usdt": 287.30, "leverage": 10.0, "seq": 8421 }
No SDK install gymnastics. Open a WebSocket, send a subscribe message, start receiving. Same shape across data channels, AI signals, execution events, and account state.
import asyncio, json, websockets async def stream(): async with websockets.connect( "wss://stream.dataliser.com/v1", extra_headers={"X-API-Key": "dl_live_..."} ) as ws: await ws.send(json.dumps({ "action": "subscribe", "channels": [ "mds.book", "mds.trades", "ai.pulse", "ai.forecast", "eds.fills", "uds.positions" ], "symbols": ["BTCUSDT", "ETHUSDT"], "venues": ["binance_perp"] })) async for msg in ws: print(json.loads(msg)) asyncio.run(stream())
Public, monthly, no sales calls on the self-serve tiers. Enterprise adds Execute, custom SLAs, and institutional-class support. Cancel anytime.
Running something bigger? Let's talk →
| Dataliser | Axon | Kaiko | CoinAPI | |
|---|---|---|---|---|
| Real-time data | ✓ 30+ venues | ✓ 30+ | ✓ 100+ | ✓ 400+ |
| AI models bundled | ✓ fleet + copilot | ✗ | ✗ | ✗ |
| EMS / OMS execution | ✓ Enterprise | ✓ | ✗ | ✗ |
| Self-serve from | $49/mo | sales-led | ~$9.5k/yr | tiered |
| Equinix-colocated | ✓ global | ✓ | ✓ | cloud |
| In-house AI stack | ✓ owned DC | n/a | n/a | n/a |
| Cancel anytime | ✓ monthly | contract | annual | ✓ |
Three ways. One, we're self-serve from $49/mo — Axon is sales-led only. Two, we bundle AI (model fleet + copilot) that Axon doesn't offer. Three, our Execute product targets prosumer traders in addition to institutions, with a lighter integration path.
Yes. We own the Dubai data center where models are trained and served, use open-source base models (no OpenAI/Anthropic API dependency), and run the entire ML stack self-hosted — vLLM, Qdrant, DeepSpeed, Triton. Your data never leaves our perimeter.
Sub-millisecond from venue tick to MDS ingress (we're Equinix-colocated at every exchange PoP). ~11ms median from there to your socket over the public internet. Every event carries four nanosecond timing checkpoints so you measure it yourself.
Yes. Execute is a technology layer — you bring your own exchange API keys and we provide the unified order-routing, rate-limit protection, risk gates, and account-state streaming. We don't custody your assets or hold your credentials beyond the signing session.
On the same normalized firehose we sell you, sliced across years of historical depth and trade data. Each signal ships with backtest stats and calibration curves so you can size positions honestly. Champion/challenger A/B runs continuously — you always get the winning model.
An in-house fine-tune of an open base model (Llama / Qwen / Mistral class), trained on financial literature and our own historical shadow-trading logs. Grounded via RAG over the live MDS stream. Function-calling access to our model fleet and backtest harness for strategy design.
Pro tier includes 7 days of replay. Elite gets 90 days. Enterprise and bespoke research licenses extend further — we have multi-year L2 captures per exchange.
Dubai HQ with the AI data center on-site, plus Equinix edge nodes at every exchange home (Tokyo, Virginia, Singapore, Zurich). Legal entity in a UAE financial free zone with appropriate licensing for data distribution and execution.
Spin up an API key in under two minutes. Stream the first message in under five. Scale from one strategy to a full trading desk on the same platform. Cancel any time — but you probably won't.