Coverage
What you get
| Item | Detail |
|---|---|
| Product code | X-REPLAY |
| Coverage | Futures first, then any tick-level product line we sell |
| Granularity | Every message in the original order, tick by tick |
| History | The last 30 days on Business; longer on Enterprise |
| Delivery | WebSocket, the same connection and message format as live data |
| Update speed | You choose: speed 1 is real time, 10 is ten times faster, 0 is as fast as possible |
A backtest reads a file. Replay pushes messages at your code, one by one, with real gaps between them. That difference matters for anything event-driven: order management, latency-sensitive logic, a bot that reconnects or throttles. If your strategy runs on a live stream, a replay is the closest you can get to testing it live without risking money.
Schema
Schema
The fields below control a replay session. Replayed messages use the normal schema of each product line, plus original_timestamp.
| Field | Type | Required | Description |
|---|---|---|---|
replay_id |
string | yes | Session ID |
symbols |
array of string | yes | e.g. ["ESZ6", "NQZ6"] |
product_lines |
array of string | yes | e.g. ["FUT-TICK", "FUT-BOOK"] |
start_timestamp |
string | yes | Replay start, UTC |
end_timestamp |
string | yes | Replay end, UTC |
speed |
number | yes | 1 = real time, 10 = ten times faster, 0 = as fast as possible |
status |
string | yes | queued, running, finished |
original_timestamp |
string | yes (per message) | Event time of the replayed record |
Example record:
{
"replay_id": "rpl_7f3c2a",
"symbols": ["ESZ6"],
"product_lines": ["FUT-TICK"],
"start_timestamp": "2026-11-18T14:30:00Z",
"end_timestamp": "2026-11-18T15:30:00Z",
"speed": 10,
"status": "running"
}
This example replays the first hour after the 9:30 a.m. Eastern cash open (14:30 UTC in November) at ten times speed. It would finish in about six minutes.
Sample data
Sample data
Replay isn't a file, so there's nothing to download. Once futures ticks are live, we plan to offer a short test session to early access members. Request one here and say which contract and hour you'd want.
Use cases
Use cases
Bot rehearsal. Point your production bot at a replay of a volatile session, such as a CPI release morning, and watch how it handles bursts of messages, order logic and risk limits. Use speed 1 to see true timing.
Fast regression tests. After a code change, replay the same five sessions at speed 0 and compare the trades your bot made with the previous version. Any difference is a behaviour change you can review.
Manual practice. Discretionary traders use replay to practise reading the tape on days they missed. Set speed to 1 or 2 and trade it on a simulator.
Debugging a live incident. If your bot did something odd at 10:14 yesterday, replay that window with start_timestamp a few minutes earlier and step through it with logging on.
Code
Code examples
Example: create a replay session with curl.
curl -X POST "https://api.marketdata.co/v1/replay/sessions" \
-H "Authorization: Bearer $MARKETDATA_API_KEY" \
-H "Content-Type: application/json" \
-d '{"symbols": ["ESZ6"], "product_lines": ["FUT-TICK"],
"start_timestamp": "2026-11-18T14:30:00Z",
"end_timestamp": "2026-11-18T15:30:00Z", "speed": 10}'
Example: Python, start a replay and collect the messages into pandas.
import json
import os
import requests
import pandas as pd
from websocket import create_connection # pip install websocket-client
key = os.environ["MARKETDATA_API_KEY"]
resp = requests.post(
"https://api.marketdata.co/v1/replay/sessions",
headers={"Authorization": f"Bearer {key}"},
json={"symbols": ["ESZ6"], "product_lines": ["FUT-TICK"],
"start_timestamp": "2026-11-18T14:30:00Z",
"end_timestamp": "2026-11-18T14:45:00Z", "speed": 0},
)
resp.raise_for_status()
replay_id = resp.json()["results"][0]["replay_id"]
ws = create_connection(f"wss://api.marketdata.co/v1/replay/{replay_id}",
header=[f"Authorization: Bearer {key}"])
rows = []
while True:
msg = json.loads(ws.recv())
if msg.get("status") == "finished":
break
rows.append(msg)
ws.close()
ticks = pd.DataFrame(rows)
ticks["original_timestamp"] = pd.to_datetime(ticks["original_timestamp"])
print(len(ticks), ticks["original_timestamp"].min(), ticks["original_timestamp"].max())
Pricing
Pricing
| Plan | Market replay |
|---|---|
| Business, $249/mo | Replay of the last 30 days, starting with futures ticks |
| Enterprise, quote | Longer replay windows |
Replay isn't sold as a dataset. Prices are early access and may change.
Vendors we studied charge $199 to $6,000 a month for plans that include replay.
Side by side
How we compare
3 of the 50 providers we studied offer market replay. One bundles the last 24 hours with its live API; another replays crypto feeds on plans that start well above ours. Our plan is a 30-day window on Business, through the same WebSocket and message format as live data, so the code you test with is the code you run.
FAQ
Frequently asked questions
How is replay different from downloading tick files?
Files give you all the data at once. Replay sends messages over a stream with their original timing, or scaled timing, so event-driven code behaves the way it would live.
Which markets can I replay?
Futures first, once our futures tick data is live. Other tick product lines would follow as we add them.
What time zone are timestamps in?
UTC. start_timestamp, end_timestamp and each message's original_timestamp are all ISO 8601 UTC.
Does replay handle contract rolls?
Replay sends the exact contracts you name in symbols. To replay across a roll, list both the old and new contract.
Can I pause or change speed mid-session?
At launch, speed is set when you create the session. Pause and seek are on our list for later.
Is replay data adjusted?
No. Replayed messages are exactly what was published at the time, which is the point.
Keep reading
Related
- Asset hub: Cross-asset
- Docs: WebSocket streaming
- Learn: Tick data vs bar data, How to backtest with 1-minute data