Your dashboard,
wired to the live session.
Running order, gaps, tyres, track status, race control, and every car's position on the circuit — pushed to your app as the session runs. No polling loop, no scraper to repair on a Sunday morning, and a signed payload you can point a public user base at.
What dashboard and bot builders build on RaceHooks
Live timing dashboards & track maps
The timing tower and the circuit map from one subscription: position, leader gap and interval, lap and sector times, plus every car's live coordinates and lap fraction. Draw the map once and the cars move because the feed moved, not because a timer fired.
Discord bots & chat integrations
Announce safety cars, red flags, fastest laps, overtakes, and retirements the moment race control says so. Each arrives as a typed event with the driver attached, so a bot template is a switch statement rather than a regex over someone's scoreboard HTML.
Overlays, extensions & second screens
One long-lived SSE connection from the browser — no public webhook host, no backend to stand up. Enough for a lower-third, a gap widget, or a tyre-age strip that sits over whatever you are already watching.
Ambient displays & home automation
Track status arrives as one named value — green, yellow, safetyCar, red — already resolved from the raw flag code, so a light strip, an e-ink panel, or a desk display can follow the session without parsing anything. The session clock and lap count sit alongside it.
One payload, straight onto the screen
Three things a fan app is usually built out of, and all three are the same subscription rendered differently: the tower, the alert, and the overlay.
Every one of these is a typed event with the driver attached — a switch statement, not a scraper. The channel is yours; the templates are one per event type.
The same timing.data fields as a compact overlay, driven from one SSE connection in the page. No backend, no webhook host, no polling.
Example interfaces, rendered from the fields above — your product, your design system. Nothing here is a template you have to adopt.
The endpoints that build it
Every route is Bearer-authenticated and versioned under /v1. Base URL https://api.racehooks.io/v1.
| Method | Path | What it gives you |
|---|---|---|
| GET | /v1/stream | Server-Sent Events over one long-lived connection — the path for a browser dashboard or an extension with nowhere to receive a webhook. |
| POST | /v1/webhooks | Subscribe an endpoint to a feed. One endpoint can carry the whole live catalog; filter by driver when a widget only cares about a few cars. |
| GET | /v1/events | The full season calendar with sessions nested on each event — what to count down to, and when to open a connection. |
| GET | /v1/data/seasons/:year/standings | Driver and constructor standings for a season, for the table every dashboard eventually grows. |
| GET | /v1/data/drivers | Canonical driver identity — number, TLA, name, team — the same ids every live payload carries. |
| GET | /v1/simulate/sessions | Replay a real session at any speed from 0.1× to 120× into your own endpoint, so you can build in midweek. Free covers 5 distinct current-season sessions and Developer 10; the full archive is Custom. |
timing.dataPosition, leader gap and interval, lap and sector times — the tower, every lap, every car.telemetry.track-positionEvery car's live position on the circuit: lap fraction plus x/y track coordinates, for the map.session.track-statusOne named status — green, yellow, safetyCar, virtualSafetyCar, safetyCarEnding, red — already resolved from the raw flag code.race-control.messagesRace control in its own words: flags, safety car calls, investigations, penalties.events.race40+ synthesized events — overtakes, pit stops, retirements, fastest laps — each carrying the driver it belongs to.driver.listNumber, TLA, full name, team and team colour. Free, and the identity every other payload keys to.tire.currentCurrent compound per driver with tyre age — the strip every timing tower grows eventually.session.lap-countCurrent lap and laps remaining; session.clock carries the countdown beside it. Both free.Developer includes all 30 live data feeds, not just the ones above; the remaining 25 in the 55-feed catalog are the Custom analytics feeds. Every id, cadence, and payload schema is documented.
Three ways the data reaches you
Pick per integration — you can run all three against one API key. Webhook and SSE frames both meter against your monthly delivery bucket; REST reads meter against the request rate limit instead.
Webhook
Push · defaultRegister an HTTPS endpoint and subscribe it to feeds. RaceHooks POSTs each event as it fires — typically well within a second. Every payload is HMAC-SHA256 signed, retried with exponential backoff on failure, and every attempt is logged in your console with headers, status, and latency.
POST /v1/webhooks
{ "webhookUrl": "https://your-app.com/hook",
"feedId": "events.race" }SSE stream
Push · no public URLOpen one long-lived connection and read frames as they arrive — no public webhook server to host or expose. Each frame is `event: <feedType>` + a JSON `data:` line, with a ping every 30s so proxies hold the connection open. Auth by Bearer header, or `?token=` for browser EventSource, which cannot set headers.
GET /v1/stream?feeds=raceevent,timingdata
Authorization: Bearer $TOKENREST
Pull · on demandQuery completed and reference data directly whenever you need it — results, standings, laps, stints, pit stops, and the segment endpoints above. Use it to backfill history, hydrate a new user, or reconcile after an outage rather than to follow a live session.
GET /v1/historical/2026/16/results
Authorization: Bearer $TOKENTest the whole thing on a quiet Tuesday
Simulate replays a real current-season session through your own webhooks at any speed from 0.1× to 120×. Your integration receives the exact payloads it would in a live race — real data, known result — so you can validate fans logic end to end before a live session ever runs. Free includes 5 sessions, Developer 10; Custom replays the full archive.
How Simulate works →What the ML layer adds for fans
Everything above is what is happening, pushed as it happens — enough to build the dashboard most people actually want. Custom adds what is likely to happen next, which is the difference between a tower and a story. On Custom, fourteen production ML models attach an analytics key to every payload you already receive — same feeds, same delivery, same code path.
Win, podium & position probabilities
analytics.race-odds carries a full position distribution per driver, recomputed as the race moves. The graphic that makes a comeback legible rather than just visible.
Overtake & battle state
analytics.battle tracks the fight between a car and the one ahead — closing rate, DRS range, how long it has been held. The cue for where to point a viewer next.
Tyre cliff & true pace
analytics.true-pace strips fuel load and tyre age out of a lap so the tower can show who is genuinely quickest, and the tyre-cliff model says how many laps are left on a set.
Mini-sector timing & classified results
timing.mini-sectors shows where in a lap the time actually went, and results.classification closes the session out with the official order.
Start on the free tier.
Build and test a complete integration on historical and replayed sessions — no credit card. Go Developer when you need it live.