The trade tape, filtered your way, sold honestly.

Keys are hand-minted while the customer count is small — you were given one that looks like tk_live_…. It is shown exactly once; we store only a keyed hash.

Minute one: the last prints over $1,000

# bare numbers are exact dollars; suffixes work: 1k, 1.5m
curl -s "$BASE/v1/flows?minUsd=1k&limit=5" \
  -H "Authorization: Bearer $TRAKTOR_KEY"copy

Every response is enveloped — { data, meta } — and every row carries its honesty fields: lagSeconds (may be negative), origin, blockTimeSource, flags[].

Minute three: the live socket

const ws = new WebSocket("ws://localhost:8790/v1/stream", ["traktor.v1"]);
ws.onmessage = ({ data }) => {
  const f = JSON.parse(data);
  if (f.op === "hello")
    ws.send(JSON.stringify({ op: "auth", id: "1", key: KEY }));
  else if (f.op === "ack" && f.re === "1")
    ws.send(JSON.stringify({ op: "subscribe", id: "2", sub: "whales",
                             filter: { side: "buy", minUsd: "5k" } }));
  else if (f.op === "ack" && f.re === "2")
    console.log("backfill anchor:", f.result.seq);   // ← §08
  else if (f.op === "events")
    for (const e of f.d) console.log(e.side, e.usdAmount, e.chain);
};copy

Minute ten belongs to the handoff — how you stitch history and live into one gapless stream. Read it before you build; it is the one integration detail everyone gets wrong on the first try.

Most feeds fabricate the figures this one leaves null, and hide the lateness this one labels. These clauses are contractual: the software conforms to them, and a claim you can catch us breaking is a bug report we want.

One key is the credential for both transports. On REST it travels in the header, and only the header:

Authorization: Bearer tk_live_…copy

On the socket the key travels in the first frame after the upgrade (browsers cannot set headers on a WebSocket, and URLs are logged — the frame is what remains). You have 5 frames, 4 KiB and 5,000 ms to authenticate; then 4001.

At rest a key is an HMAC under a server-side pepper. Revocation bites on the next request; the in-process cache bound is 5 seconds, the absolute worst case 300. Unknown and malformed keys answer identically — there is nothing to enumerate.

The same filter object drives /v1/flows and a socket subscription, and it means the same thing on both — enforced by one shared evaluator and proven by a replay harness before anything ships. Every predicate is a pure function of the row.

Flat conjunction only — list fields give OR within a dimension; there are no AND/OR/NOT trees. The machine-readable grammar, with ranges, costs and the caveat vocabulary, lives at /v1/meta/filters.

Ordering: the arrival axis

Both directions walk (ingestedAt, _id) — "the last N trades" means last N by arrival, because on this tape chain time runs backwards for four rows in ten (§2.1). order=desc (default) pages back from now; order=asc tails forward, holding back the newest ~2 seconds so a row can never land beneath a cursor you already hold.

Cursors

Two kinds, one conversion point, all opaque:

Re-send the identical filter set on every page (400 cursor_query_mismatch otherwise); only limit may change. An empty ascending page echoes its position — poll the same cursor every 1–5 s to tail over REST. Tampering earns a flat 400 invalid_cursor that never says which check failed; a position under the retention floor earns 410 with a details.resumeCursor.

Money, on every answer

RateLimit-Limit / -Remaining / -Reset ride every response; X-Traktor-Cost says what the request billed (a 304 bills zero — ETags hash the data, so conditional polling is nearly free). /v1/flows costs 1 + ceil(limit/100) units; point reads cost 1; meta routes are free but still rate-armed.

Build up to 100 account-scoped rules from the closed vocabulary at /v1/alert-capabilities. Rules combine up to 12 conditions, scope up to 50 token or wallet addresses, and choose crossing, repeat or one-shot delivery. Matches arrive in the private notification feed; edits use an optimistic revision, and duplicates start disabled.

A browser bearer is stored only as a SHA-256 hash, is bound to its source API key, and becomes invalid as soon as that key is revoked or expires. The web proxy keeps it in an HttpOnly, SameSite=Strict, production __Host- cookie. Preview is read-only and bounded to six calls/minute, burst three, 250 candidate subjects and a three-second Mongo budget.

/v1/stream, subprotocol traktor.v1. Text frames, one JSON object each, every frame { op, id }, responses echo re. Exactly one terminal answer — one ack or one error — per client frame. The server refuses unknown fields (a typo must not silently widen a filter); you ignore unknown server ops.

Resume

Reconnect and subscribe with from: <last seq you processed>. A same-epoch, in-window span replays exactly — no gap, no duplicate, because every v1 predicate is pure. A trimmed span, a stale epoch, or a resume outside your plan's replay window is answered on the ack (resumed: false, gap: { reason }) — never a silent hole. Backfill the gap over REST from the new anchor and dedupe on id.

Flow control

If your socket cannot keep up, the oldest queued events for that subscription drop — counted, noticed within a second, cumulative on every heartbeat, and never billed. Shedding never closes the connection; 4008 is reserved for a socket that stops reading TCP entirely. Under pressure the server may widen your batching (and says so); it never narrows it. Send any frame each 30 s — a ping works; 45 s of silence closes 4009, retry at once.

How to stitch history and live into one stream without a gap — the one integration detail three separate designs got wrong in three different ways, settled:

1. subscribe FIRST — the ack's result.seq is your anchor
2. page GET /v1/flows?cursor=<that seq> backwards, same filter
3. dedupe on id across the seamcopy

Gap-free by construction: the socket is attached before the backfill query runs, so nothing inserted during the backfill can fall between the halves. Not duplicate-free, on purpose: the seam is at-least-once. Size your seen-set honestly — twenty minutes of paging at the measured peak (~1,750 rows/min) is roughly 35,000 ids, not a handful.

Everything the dashboard shows, on the same key. GET /v1/market serves several views in one body — views= any of summary, tokens, series, tape, rotation, wallets — and every view is also its own route:

One grammar — chains, platforms, windowMinutes, side, minTradeUsd, minWalletBalanceUsd, launchpads, dexSignals, feeSharing, stockPairs and every screen by its key — published with units, bounds, costs and provenance at /v1/meta/filters under market. Each route reads only what it can act on and refuses the rest by name (400 unknown_parameter, with details.accepts): side and minTradeUsd screen single trades, so only tape reads them. dexSignals takes paid (a paid DexScreener profile and social update), boost (boost spend), and cto (a GMGN-reported community takeover); the choices are OR within the facet, and every view that reads launchpads reads it too. Bucket-backed views take every window on every plan; tape, rotation and wallets read raw trades and are gated by your plan's history (403 plan_forbids). A balance floor selecting more than 5,000 wallets is 422 filter_too_broad before anything runs.

curl -s "$BASE/v1/market?views=tokens,series&windowMinutes=60&launchpads=flap&minNet=5k" \
  -H "Authorization: Bearer $KEY" | jq '.data.tokens[:3] | map({ticker, netUsd, marketCap, metadataAt})'copy

Fresh market reads and ranking

Market REST and public subscriptions share one committed-data producer. Token rows refresh after committed changes; advancing the minute rebuilds the rolling window. Responses use private, max-age=1 and date their build with meta.asOf. Token routes accept sort, dir=asc|desc, named=1 and tail=1; tail cannot combine with a nonzero offset. Supported market windows are 5, 15, 30, 60, 240, 1440 and 10080 minutes.

Public market streaming

GET /v1/public/market?resource=flow&query=... returns bounded public resource JSON. Resources are flow, quote, token, saved, stocks, assets and feed. The query uses the web vocabulary (chain, platform, window, screens and ranking), capped at 24 hours.

Connect to /v1/market/stream with subprotocol traktor.market.v1, without credentials or URL parameters. Subscribe with the same query. The server sends reset, then a complete snapshot; update replaces the whole view. Each carries sub, revision, cursor, updatedAt and data. An unchanged rebuild sends current with the same revision and a new freshness time. Send ping on heartbeats. Reconnect and resubscribe after a reset or lost connection; market cursors do not promise execution-level replay. The authenticated traktor.v1 protocol continues to serve raw trades, and rejects market filters such as maxMcap.

{"op":"subscribe","id":"sidebar","query":{"resource":"flow","params":"chain=bnb&window=240&views=tokens&sort=mcap&limit=40"}}copy

Identical public queries share a producer. Limits per process: 256 sockets, eight per IP, 16 subscriptions per socket, 96 groups, three simultaneous reads and 4 MiB response frames. Slow readers reconnect for a new snapshot. Trading commands retain authenticated, idempotent HTTP endpoints.

Two clocks on the row

Current valuation carries valuationSource, marketPriceUpdatedAt and valuationExpiresAt, covering verified pool prices and provider fallback. liquidity, ticker and logo are DexScreener's, dated by metadataAt; launchpad, graduated, athPrice and both social signals are GMGN's, dated by gmgnAt (dexscreenerSocialsUpdated is named for what GMGN reports on, not for who reported it). Our own numbers — flow, buyers, holders, holder-reward verification — are as fresh as the tape. The whole table is market.provenance.

Pool depth

GET /v1/pools/{chain}/{token} returns the deepest readable pool as exact per-range segments — USD price bounds, the tokens sitting in the range, and the USD that must flow to cross it — so binning it to a chart never refetches. Ten units, because a cold read is ~40 RPC calls; the 10-second cache makes the second reader nearly free. Failures name their cause: 404 pool_not_found, 422 pool_unreadable, 502 upstream_failed with details.source.

These numbers are read live from /v1/plans when you load this page; the ack's limits object is authoritative at runtime — read it, don't hard-code this table.

The feed's measured mean is ~15.6 events/s with bursts to 29/s: Pro carries the firehose; Free deliberately cannot on a wide filter — the ack warns (rate_cap_below_feed) and drop notices make the shedding visible, never silent. Non-payment downgrades entitlement to Free; it never revokes your key.

Every REST error is { error: { code, message, requestId, details, docs } } — code is stable forever and the only thing to branch on. The load-bearing ones:

Socket close codes

Every server-initiated close is preceded by a bye frame with detail and retryable. An unknown 4xxx code is not retryable unless its bye said so.