How iRacing SDK data becomes a live broadcast overlay

The iRacing SDK is a local live-data connection exposed by the simulator. An app such as EDR Broadcast reads timing, position, driver, car, flag and telemetry values, works out what they mean for the race, and displays them through transparent browser-source overlays in OBS or vMix. You do not need to write code or install a developer kit to use it, but knowing the path explains why overlays need an active iRacing session, why some information updates instantly and why an overlay can show more than the native spectator UI.

Terms you will hear

• iRacing SDK. The simulator’s local live-data interface. It exposes current session and telemetry information to compatible software on the Windows PC.
• iRacing data API. An account-based web service used for published results, league, series and historical information. It is not a substitute for the live session feed.
• Browser-source overlay. A transparent web page loaded inside OBS or vMix. Broadcast software updates the page while the production software composites it over the simulator video.
• Derived broadcast logic. Information calculated from the feed, such as battle scores, movers, incident candidates and camera priorities. These are application features, not ready-made SDK fields.

The live broadcast data path

1. iRacing runs the session. The simulator knows every car, lap, sector, flag, camera target and live telemetry value.
2. Broadcast software reads the local feed. The app connects on the same Windows PC and listens for current session data. It does not need to guess positions from the video.
3. Raw values are turned into race information. The software sorts classes, calculates gaps, identifies battles, watches changes and decides which values are useful to viewers.
4. The overlay is rendered. EDR Broadcast turns that processed state into individual transparent web graphics such as a leaderboard, driver card, flag banner or track map.
5. OBS composites the show. Each supplied URL is added as a browser source above the iRacing game capture. OBS combines the video, graphics, commentary and sponsor assets.
6. Optional remote services share selected data. A current timing view or authorised controls can be sent to remote crew; in EDR Broadcast, cloud relay, remote browser control and public live timing are League features. The host still remains the source of the live iRacing session.

What iRacing data can appear on a broadcast

Live information	What the app does with it	Viewer graphic
Position, lap and class	Sorts the field and calculates useful gaps	Leaderboard, relative and class standings
Driver, team and car details	Matches the focused car to its identity and class	Driver card, lower third and grid introduction
Speed, gear and driver inputs	Cleans and formats fast-changing telemetry	Telemetry panel and tacho
Track position	Places each car on the circuit and groups by class	Track map and battle context
Flags and session state	Interprets green, yellow, white, chequered and restart conditions	Flag banner, race status and caution graphics
Changes over time	Scores battles, movers and possible incident patterns	Battle box, movers board, incident log and Auto-Director decisions

Important distinction. The SDK supplies data. It does not supply a finished broadcast story. Battle detection, incident candidates, class logic, graphic design and camera decisions are software features built on top of the feed.

Why browser-source overlays suit OBS

A browser source is a transparent web page inside OBS. The page can redraw text, timing rows, colours and animations without touching the underlying iRacing video. That keeps every graphic modular: hide the leaderboard, show a driver card, trigger a yellow flag banner or switch themes without rebuilding the game capture. The operator works with structured timing and production controls, while viewers see only the selected information as clean broadcast graphics.

For the practical setup, use the OBS browser-source overlay guide. It covers canvas size, layering, transparency, refresh behaviour and troubleshooting.

Live SDK data vs the iRacing data API

These are different tools for different timing. The live SDK feed comes from the running simulator and is suited to current position, telemetry, flags and camera control. The iRacing data API is used for account-based information such as published results, series, leagues and historical records. A broadcast app may use both, but the data API does not replace the live feed during a race.

This distinction also explains why a replay or spectator client must be in the session for live overlays to populate. A web page cannot produce current race data on its own if no host is connected to iRacing.

What good broadcast software adds beyond the SDK

Multiclass logic

A useful tower needs class colours, class positions, leader handling and sensible gaps, not just a raw overall-position number.

Stable presentation

Fast values must be smoothed and state changes handled so the graphic remains readable instead of flickering or jumping.

Story selection

Battle scoring and anti-repetition help the camera cover a race, not simply follow the overall leader for an hour.

Replay workflow

Logging the moment, choosing a camera, showing the replay and returning live are production actions, not raw telemetry fields. The incident detection and replay guide shows how the same live session is used to catch moments outside the camera.

Operator control

The producer needs predictable buttons, overrides and feedback when race night becomes chaotic.

Remote safety

A remote crew system needs authorised roles, scoped controls and a host that remains in charge of the local session.

Why an overlay is blank or showing old data

No active session. Open an iRacing session on the host PC. The UI or member website alone does not provide the live feed.

The broadcast app connected before iRacing was ready. Restart the app or reconnect after the simulator has fully loaded into the session.

OBS cached the browser source. Refresh the source, confirm the URL and use the source’s refresh-on-activation option only if the overlay documentation recommends it.

The wrong scene size is being used. Set the browser source to the intended canvas, commonly 1920x1080, then transform it to fit rather than cropping the web page.

A replay changed the meaning of the feed. Some values behave differently while spectating or replaying. Good broadcast software accounts for that state, but the producer should still test the exact workflow.

For a full first setup, start with how to broadcast iRacing with OBS.