Build the live race view
your audience wants.
Connect running order, gaps, tyres, track status and race control to your dashboard, bot or overlay. Start with a recorded session, choose the feeds your audience needs, and review plan limits and permitted use before launch.
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 29 live data feeds, not just the ones above; the remaining 26 in the 56-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 are both counted as deliveries (Free pauses at its monthly limit; Developer has no delivery limit); REST reads count against the request rate limit instead.
Webhook
Push · defaultRegister an HTTPS endpoint and subscribe it to feeds. RaceHooks POSTs events as source updates arrive. 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. Model outputs publish only on supported sessions, schedules and eligible race states. Review the output contracts and evaluation scope with us.
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.
Let your users play against the model
A hosted beat-the-model strip that sits next to your own leaderboard, with a compact win-probability card beside it. The app below is a fictional example and every value is illustrative.
Kivo Picks is a fictional fan prediction app. Drops into an app or site. The beat-the-model strip sits next to your own leaderboard.
Driver names appear as plain text. No driver images, team marks or series branding. Every graphic carries the RaceHooks credit and a not-affiliated notice.
Start on the free tier.
Build and test a complete integration on historical and replayed sessions, with no credit card. Go Developer when you need it live.