Preview · Coming soon

The Motorsport Live Streaming Platform

Stream the track.
Build the product.

LapsHub Live API puts cars in motion as continuous telemetry streams and low-latency onboard video stages. Your software subscribes. Your UI stays yours.

Request access Read the specs

Live telemetry · Sub-2 s onboard video · Org-scoped API keys

Live map · onboard feed

What your product renders: streams of position and laps, plus onboard video when you need eyes in the car.

Stop stitching live together. Start shipping products.

One platform for motorsport live data and video so your team builds experiences, not transport glue.

Replace DIY live stacks

Drop the custom WebRTC brokers, ad-hoc MQTT topics, and one-off auth. Open a session, stream points, mint video tokens.

Keep telemetry and video in sync

Same org → car → session model for GPS, laps, and onboard stages. One clock for the paddock view you render.

Ship pit walls faster

Team software and series apps subscribe to streams and compose their own UI on top.

What you can build

If your product needs to react while cars are on track, Live API is the streaming layer underneath.

hub

Event-driven pit walls

Maps, timing boards, and crew views that update from live telemetry streams instead of polling stale snapshots.

live_tv

Onboard for authorized viewers

Mint short-lived viewer tokens for crew and partners. Pair sub-2-second onboard video with the same session’s data stream.

flag

Series & customer portals

Fan live position and optional video into the products your teams and members already use.

sensors

Integrations & overlays

Feed broadcast overlays, timing displays, and partner stacks from a documented control plane and MQTT contract.

The LapsHub difference

A complete live streaming platform for motorsport: stream telemetry, stage video, govern access, and meter usage in one contract.

Complete

REST for session and stage lifecycle. MQTT for high-Hz points. WebRTC tokens for onboard video. Usage meters for publisher, subscriber, and message volume.

Motorsport-native

Organization, car, session, stage, and telemetry channel are first-class. Built for race weekends and track days, not generic IoT demos.

Your UI

We move streams and mint tokens. You ship the brand, the pit wall, and the live experience your customers pay for.

How live streaming works on LapsHub

Traditional APIs wait for a request. Live streaming flips the model: cars publish continuous events, and your clients subscribe to the streams they need.

1

Stream

Open a session for a car. Publish GPS, laps, and channels to a session-scoped MQTT topic. Subscribe from every surface that needs the live picture.

2

Stage

Create a video stage on the same session. Publish onboard WebRTC with a publisher token. Mint viewer tokens only while someone is watching.

3

Govern & meter

Org API keys scope every call. Idle viewer timeouts and usage meters keep cost aligned with real publisher, subscriber, and message load.

Organization
  └── Car
        └── Session
              ├── Stage (video) → publisher token / viewer tokens
              └── Telemetry channel (MQTT topic ACL)

Start from the control plane

Org-scoped Bearer keys. HTTPS REST for sessions and stages. Video media stays WebRTC; telemetry stays MQTT.

Authorization: Bearer lh_live_<org>_<secret>
Create session
curl -sS -X POST https://api.lapshub.com/v1/cars/car_01/sessions \
  -H "Authorization: Bearer lh_live_org_example_secret" \
  -H "Content-Type: application/json" \
  -d '{"trackId":"road-america","externalId":"practice-1"}'
Create stage (publisher token)
curl -sS -X POST https://api.lapshub.com/v1/sessions/ses_01/stages \
  -H "Authorization: Bearer lh_live_org_example_secret" \
  -H "Content-Type: application/json" \
  -d '{}'
Mint viewer token
curl -sS -X POST https://api.lapshub.com/v1/sessions/ses_01/stages/stg_01/viewer-tokens \
  -H "Authorization: Bearer lh_live_org_example_secret"

Specifications

Machine-readable contracts for review, planning, and codegen. The same surface design partners will build against.

video.publisher

Participant-seconds while a publisher is connected.

video.subscriber

Participant-seconds while a viewer stays connected.

telemetry.message

Count of accepted MQTT messages or batch items.

Need a turnkey paddock UI instead of raw APIs? See LapsHub Live Platform.

Frequently asked questions

What is motorsport live streaming?

Treating car data and onboard video as continuous streams while a session is live, not as files you download after the run. Telemetry points and video tokens flow as events so pit walls, series apps, and crew views can react in real time.

How is this different from a traditional timing API?

Request-response APIs ask for the latest lap or position when a client polls. Live streaming publishes events as they happen. Your product subscribes once and stays current for the whole session.

What about low-latency onboard video?

Video is a first-class path beside telemetry. Create a stage on the session, publish with WebRTC, and mint short-lived viewer tokens. Target latency is sub-2 seconds for crew and authorized viewers.

Who is Live API for?

Integrators building team software, series apps, timing products, and overlays. Drivers can keep using the free LapsHub app. Your product owns the UI your customers see.

How do I get started?

Read the OpenAPI and AsyncAPI specs on this page, then request design-partner access. We will follow up on architecture, metering, and onboarding.

See Live API in your stack

Request design-partner access. Tell us about your product and we will map sessions, streams, and video stages to your roadmap.

Include in your email:

  1. Company / org
  2. Use case (team software, series app, timing product, other)
  3. Typical cars / concurrent viewers
  4. Need live video? (Y / N)
  5. Timeline
Request access Read the specs

Preview program for design partners. Drivers: download the free app or join Discord.