Developer hub
Build on the platform broadcasters run on
Create matches, feed scores, fire graphics, react to events, and ship code or native Rive graphics. One API key, and docs that match what is deployed.
docs.ligr.live
Everything around the graphic, in one API
The same platform that runs live competitions, open to your code. Items marked beta can still change between minor versions.
- REST APIMatches, facts, teams, overlays, streams and themes. JSON in and out, with scoped keys that expire.API reference
- WebhooksSigned POST requests when a match, fact, summary, team, competition or overlay changes, per competition.Webhooks
- Graphics SDKBetaWrite a graphic in HTML, CSS and JavaScript. It talks ligr.gfx.v1 to the overlay and publishes into a theme.Start building
- Rive graphicsBetaImport a native Rive runtime or source project, bind live sports data, publish exact versions and create operator presets.Import Rive
- Overlays & control roomFire control room presets or graphics commands over REST, and set up a whole match session before anyone opens the dashboard.Control room
- For AI agentsllms.txt, a Markdown twin of every page, the OpenAPI document and six rules an agent must follow.AI agents
REST API
One key. Scoped. Expiring
Your fixtures system, score feed or results site, talking to LIGR.
Every request goes to https://api.ligr.live/rest with an API key as a Bearer token. A key belongs to one organisation and carries per-resource scopes, <resource>:read or <resource>:write, and an expiry of 7, 30, 60 or 90 days, one year or a custom date.
curl 'https://api.ligr.live/rest/v2/matches?limit=1' \
-H 'Authorization: Bearer YOUR_READ_KEY'matches:read, and it returns one match as JSON.What you can do with it
- Create matches, teams, venues and competitions
- Score a match by posting facts: goals, cards, points, substitutions
- Create overlays and fire control room presets or graphics commands
- Push external data sources, such as a standings table, to every overlay of a competition
- RateLimit headers on every response, so your client can pace itself
Code graphics Beta
Web graphics. Live data. One protocol
No proprietary tools. Your graphic is a web page.
A code graphic is HTML, CSS and JavaScript. The LIGR overlay loads it in a transparent frame over the video, sends it live match data, and tells it when to show and when to hide. The two sides talk over postMessage with the ligr.gfx.v1 protocol: the overlay says HELLO, your graphic answers READY, and every change after that arrives as a GRAPHIC_UPDATE.
Operators show and hide a code graphic the same way as any other graphic, and automation and REST commands drive it by its control variables. You only build the bundle.
The ligr.gfx.v1 protocolconst PROTOCOL = 'ligr.gfx.v1'
let sessionId = null
let parentOrigin = '*'
let seq = 0
export function send(type, payload) {
window.parent.postMessage({ protocol: PROTOCOL, sessionId, seq: ++seq, type, payload }, parentOrigin)
}
export function listen(handlers) {
window.addEventListener('message', (event) => {
const msg = event.data
if (!msg || msg.protocol !== PROTOCOL) return
if (msg.type === 'HELLO') {
sessionId = msg.sessionId
parentOrigin = event.origin || '*'
send('READY', { version: '1.0.0' })
return
}
if (msg.sessionId !== sessionId) return
if (msg.type === 'PING') {
send('PONG', {})
return
}
handlers[msg.type]?.(msg.payload)
})
}How it works
From your editor to the overlay
Publishing is versioned. Nothing reaches air by being pushed: only activating a theme version changes what an overlay loads.
- 01Write the graphicPlain HTML, CSS and JavaScript, with a manifest (graphic.json) that declares its runtime and control variables.
- 02Speak ligr.gfx.v1The overlay sends match data, control variables, theme variables and external data over postMessage. Your graphic answers.
- 03Push the bundleCreate the theme and the graphic, upload the built files and record the bundle, with the ligr-graphic CLI or REST.
- 04Publish and activatePublish a graphic version, then a theme version that holds it. Overlays render the active theme version.
Runtime
The overlay is a GPU-accelerated Chromium browser
Any rendering library that runs in a browser runs in your graphic. Keep every frame under 16 ms at 60 fps.
- WebGL 1 and 2
- WebGPU
- Canvas 2D
- CSS animations
- Web Animations API
- WebAssembly
- Web Workers
- Three.js
- PixiJS
- Rive
- Lottie
- GSAP
Webhooks
Webhooks: stop polling
One signed POST per change, for the competitions and events you subscribe to. Build your receiver to the delivery contract and it stays in step with every match.
- Events for matches, facts, summaries, teams, competitions and overlays
- Signed with your organisation's secret, so you can prove LIGR sent it
- Retries: up to 6 attempts for match, fact and summary events, 3 for the rest
- At-least-once delivery. Deduplicate on (entity, data.id, date)
- Delivery health and logs in the dashboard
For AI agents
Built for AI agents too
Give a coding agent the docs index and a scoped key. The docs are written to be read by machines as well as people.
- /llms.txt, /llms-full.txt and per-section files
- A Markdown twin of every page
- /openapi.json for every endpoint and response shape
- Six rules, including: never activate a theme version during a live match
Questions
At docs.ligr.live. They cover authentication, the REST reference, webhooks, the Graphics SDK, native Rive graphics, overlays and control rooms, and step-by-step guides with curl. Every page also has a Markdown twin, and the site serves llms.txt and an OpenAPI document for tools and AI agents.
Ready to build?
The docs, the API reference and the guides are at docs.ligr.live. For a league-wide integration, talk to us.