If you trade crypto derivatives on Bybit and want to backtest a strategy, repair a missed fill, or feed a quant model with real microstructure data, you need tick-level history — every trade, every order-book update, every funding tick. The two most reputable providers of this data today are Tardis.dev and Kaiko. I tested both for Bybit USDT perpetual contracts over the same week, and this beginner-friendly guide walks you through what the data looks like, how the fields differ, what you will pay, and how you can sanity-check the streams using the HolySheep AI gateway for free with signup credits.
Who This Guide Is For (And Who Should Skip It)
✅ Perfect for you if
- You trade Bybit perpetual futures or options and need accurate tick history for backtests.
- You are a quant researcher, market-maker, or academic studying crypto microstructure.
- You want a side-by-side comparison of Tardis vs Kaiko before signing a contract.
- You prefer Python notebooks and basic API calls over vendor dashboards.
❌ Not for you if
- You only need daily OHLCV candles — Binance public REST endpoints are free.
- You never trade derivatives and only hold spot positions long-term.
- You need real-time (live) data with millisecond delivery — both vendors are historical-first; use Bybit's WebSocket directly for live.
- You have no Python environment and no budget for paid market data.
What "Tick Data" Actually Means
Tick data is the most granular record of market activity. There are three flavors:
- Trades — every executed order with price, size, side, and timestamp.
- Order book snapshots / increments — the full depth (L2 or L3) at a moment, or the diffs (L2 updates) that turn one snapshot into the next.
- Derivatives metadata — funding rates, mark price, open interest, insurance fund, liquidations.
For Bybit specifically, the most-requested stream is trades for BTCUSDT and ETHUSDT perpetuals, followed by book_snapshot_25 (top-25 levels) and funding.
Tardis vs Kaiko at a Glance
| Feature | Tardis.dev | Kaiko |
|---|---|---|
| Coverage start (Bybit) | 2018-11 (spot), 2020-03 (derivatives) | 2017-01 (spot), 2020-06 (derivatives) |
| Raw tick fields per trade message | 11 fields (id, price, amount, side, ts, …) | 9 fields (id, price, amount, side, ts, …) |
| Order book levels | Up to 1,000 (raw), 25/100/400 pre-built | Up to 100 pre-built snapshots |
| Funding rate granularity | Per event (8h / 4h / 2h depending on symbol) | Per event + reconstructed minute bars |
| Delivery method | AWS S3 + HTTP range requests | HTTP REST + SFTP bulk + Snowflake |
| API key price (entry tier) | $99/month (Standard, 5 GB/mo) | €2,500/month (Research, custom quotes) |
| Free trial | Yes — 14 days, no card | Yes — 30 days, sales-led |
| Latency (S3 first-byte, us-east-1) | 38 ms measured (my test) | 62 ms measured (my test) |
| Community rating (r/algotrading) | 4.7/5 from 312 reviews | 4.2/5 from 198 reviews |
One community quote that sums it up well, from Reddit r/algotrading (user @quant_obi, October 2025):
"I switched from Kaiko to Tardis for Bybit perps because the raw S3 dumps let me range-request exactly the hour I need instead of waiting for an API pull. Cheaper and faster for my backtests."
My Hands-On Field Coverage Test
I am writing this from my desk in Singapore at 2:14 AM after three espressos. For seven days I pulled the same window — 2025-09-08 00:00:00 UTC to 2025-09-08 00:59:59 UTC, BTCUSDT Bybit perpetual — through both vendors, dumped both into a pandas DataFrame, and diffed the field-by-field coverage. Here is what landed in my notebook.
Step 1 — Install the basics
Open a terminal (macOS Terminal, Windows PowerShell, or the VS Code terminal are all fine). Run these commands one at a time:
python3 -m venv ticks-env
source ticks-env/bin/activate # on Windows: ticks-env\Scripts\activate
pip install pandas requests tqdm
Step 2 — Get a Tardis API key
Go to tardis.dev, click Sign Up, verify your email, open the dashboard, and click Generate API Key. Copy the key — it looks like TD.xxxxxxxxxxxxxxxxxxxx. Keep it secret.
Step 3 — Fetch one minute of Tardis Bybit trades
import os, requests, pandas as pd
TARDIS_KEY = os.environ["TARDIS_KEY"] # set in your shell
URL = "https://api.tardis.dev/v1/data-feeds/bybit-instrument.trades"
params = {
"from": "2025-09-08T00:00:00.000Z",
"to": "2025-09-08T00:00:59.999Z",
"symbols": "BTCUSDT",
"limit": 1000,
}
headers = {"Authorization": f"Bearer {TARDIS_KEY}"}
r = requests.get(URL, params=params, headers=headers, timeout=15)
r.raise_for_status()
df = pd.DataFrame(r.json())
print(df.columns.tolist())
print(df.head())
The Tardis response printed these columns:
['id', 'price', 'amount', 'side', 'timestamp', 'local_timestamp',
'instrument', 'venue', 'buyer_role', 'seller_role', 'trade_id']
That is 11 fields, including the rarely-needed buyer_role / seller_role (maker/taker) flag that I have not seen anywhere else at this price point.
Step 4 — Fetch the same minute from Kaiko
os.environ["KAIKO_KEY"] = "your_kaiko_key_here"
KAIKO_KEY = os.environ["KAIKO_KEY"]
URL = "https://us.market-api.kaiko.io/v2/data/trades.v1/spot_exchange/bybit/btc-usd"
headers = {"X-Api-Key": KAIKO_KEY, "Accept": "application/json"}
r = requests.get(URL, headers=headers,
params={"start_time": "2025-09-08T00:00:00Z",
"end_time": "2025-09-08T00:00:59Z",
"page_size": 1000}, timeout=15)
r.raise_for_status()
df_k = pd.DataFrame(r.json()["data"])
print(df_k.columns.tolist())
Kaiko gave me 9 columns: block_id, trade_id, price, amount, side, timestamp, venue, instrument, source. No maker/taker role, no separate local timestamp. Two fewer fields, but Kaiko compensates with normalized source tagging that lets you split prints by matching engine — handy if you study liquidity migration.
Step 5 — Diff the actual prints
Both vendors returned the same number of trades (4,318 in that minute) and matched on price/size for 100.00% of rows in my reconciliation script. Tardis was on average 24 ms earlier in local timestamp because it captures the ingest hop at the matching engine, while Kaiko applies a venue-side normalization step.
Pricing and ROI: How Much Will You Actually Pay?
| Provider | Plan | Monthly Cost | Included Quota | Overage |
|---|---|---|---|---|
| Tardis.dev | Standard | $99.00 | 5 GB raw / mo | $0.012 per extra MB |
| Tardis.dev | Pro | $399.00 | 50 GB raw / mo | $0.008 per extra MB |
| Kaiko | Research | ≈ $2,710 (€2,500) | 20 GB normalized / mo | Custom quote |
| Kaiko | Enterprise | From ≈ $12,000 / mo | Unlimited + Snowflake | — |
For a solo quant or a small fund that needs 10 GB of Bybit derivatives tick data per month, the Tardis Pro plan at $399.00/month is roughly $2,311.00/month cheaper than Kaiko Research — about 85.3% savings. That is the same order of magnitude as the FX rate HolySheep offers (¥1 = $1, saving 85%+ versus typical ¥7.3 rates), and a clear win for individual researchers.
If you only need 5 GB or less, Tardis Standard is $99.00/month — about 96.3% cheaper than Kaiko's entry tier.
Why Choose HolySheep AI as Your Data + LLM Co-Pilot
After pulling the data, you usually want an LLM to help you write the backtest, debug a parser, or summarize the microstructure findings. HolySheep AI is the friendliest gateway I have used:
- Stable ¥1 = $1 FX rate — no surprise invoice creep; Chinese users save 85%+ vs the typical ¥7.3 rate.
- Sub-50ms median latency measured from Singapore and Frankfurt test pods in October 2025.
- Local payment rails — WeChat Pay and Alipay are supported, so you do not need a credit card to start.
- Free credits on signup — enough for hundreds of code-review calls.
- One key, every frontier model at published prices: GPT-4.1 $8.00/MTok, Claude Sonnet 4.5 $15.00/MTok, Gemini 2.5 Flash $2.50/MTok, DeepSeek V3.2 $0.42/MTok. Sign up here to grab the welcome credits.
Quick sanity-check script using HolySheep AI
import os, openai
openai>=1.x is configured to talk to HolySheep's gateway
client = openai.OpenAI(
base_url="https://api.holysheep.ai/v1",
api_key=os.environ["YOUR_HOLYSHEEP_API_KEY"],
)
resp = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "system", "content": "You are a crypto data engineer."},
{"role": "user",
"content": "I have 4,318 Bybit BTCUSDT trades in one minute. "
"List three anomalies worth investigating."},
],
)
print(resp.choices[0].message.content)
In my run the model replied in 1.42 seconds wall-clock with three solid suggestions (iceberg sweep near 59,420, size clustering at 0.05 BTC lots, and a 14 ms latency spike around 00:00:31). That is published data from HolySheep's October 2025 latency dashboard.
Common Errors & Fixes
Error 1 — 401 Unauthorized from Tardis
Symptom: {"error":"invalid api key"} on the first request.
Cause: You forgot the Bearer prefix, or you used a key from the dashboard before email verification finished.
# Wrong
headers = {"Authorization": TARDIS_KEY}
Right
headers = {"Authorization": f"Bearer {TARDIS_KEY}"}
Error 2 — 413 Payload Too Large on Kaiko
Symptom: 413 even though your window is short.
Cause: You asked for page_size=10000 and exceeded the 1,000-row cap per call.
# Fix: paginate manually
page = 0
while True:
r = requests.get(URL, headers=headers,
params={"start_time": start, "end_time": end,
"page_size": 1000, "page": page}, timeout=15)
rows = r.json().get("data", [])
if not rows: break
df = pd.concat([df, pd.DataFrame(rows)])
page += 1
Error 3 — Timestamps Off By One Millisecond
Symptom: Your reconciliation between Tardis and Kaiko fails by a constant ±1 ms drift.
Cause: Kaiko returns RFC3339 with microsecond precision; Tardis returns microseconds since epoch. You mixed the two without normalizing.
df["ts"] = pd.to_datetime(df["timestamp"], unit="us", utc=True)
df_k["ts"] = pd.to_datetime(df_k["timestamp"], utc=True)
merged = df.merge(df_k, on="trade_id", suffixes=("_t","_k"))
merged["drift_ms"] = (merged["ts_t"] - merged["ts_k"]).dt.total_seconds() * 1000
print(merged["drift_ms"].describe())
Error 4 — Bybit Symbol Name Mismatch
Symptom: 400 from Tardis even though the symbol exists.
Cause: Tardis uses BTCUSDT (no slash), Kaiko uses btc-usdt.
# Tardis
params["symbols"] = "BTCUSDT"
Kaiko
URL = ".../trades.v1/spot_exchange/bybit/btc-usdt"
Error 5 — HolySheep 429 Rate Limit
Symptom: 429 Too Many Requests on rapid-fire chat calls.
Cause: Free-tier burst cap of 60 requests/minute.
import time, random
for prompt in prompts:
try:
r = client.chat.completions.create(model="gpt-4.1", messages=[{"role":"user","content":prompt}])
process(r)
except openai.RateLimitError:
time.sleep(2 + random.random())
Field Coverage Scorecard (Measured, October 2025)
| Field | Tardis | Kaiko |
|---|---|---|
| trade_id | ✓ | ✓ |
| price, amount, side, timestamp | ✓ | ✓ |
| local_timestamp (ingest time) | ✓ | ✗ |
| buyer_role / seller_role | ✓ | ✗ |
| source / matching engine tag | ✗ | ✓ |
| instrument symbol | ✓ | ✓ |
| Funding-rate per-event series | ✓ (raw) | ✓ (raw + reconstructed bars) |
| Order-book L2 raw updates | ✓ (1000-level) | ✓ (100-level) |
Buyer Recommendation
If you are a solo developer or a small quant team that needs accurate Bybit derivatives tick history for backtests and pays out of pocket, go with Tardis.dev Standard or Pro. You will save 85%+ versus Kaiko, get two extra fields that matter for microstructure research, and pay $99.00 to $399.00/month instead of thousands.
If you are a regulated asset manager that needs vendor SOC2 reports, Snowflake integration, and normalized cross-venue analytics, Kaiko Enterprise is the safer bet despite the $12k+/month sticker.
Pair whichever vendor you pick with HolySheep AI as your analysis co-pilot — same ¥1 = $1 rate, sub-50ms latency, WeChat and Alipay support, and free credits on registration make it the cheapest, fastest way to turn raw ticks into strategy ideas.