Tag a whole stint's worth of photos with the wrong driver name and editorial clients get an inaccurate caption, archive systems that index by driver can't find the images later, and fixing a multi-hour block of mistagged files after the fact takes longer than building the CSV correctly per stint would have.
Understanding the problem
CSV integration in WEC photography is matching the car number your photos show against a start-list CSV that carries driver, team, and class for every entry. RaceTagger's CSV template has a Number column, a Driver column, and a Category column, and it classifies each car's visual class as Hypercar, LMP2, or GT3 and cross-checks that against your list (LMDh-chassis cars compete within the Hypercar class, so they belong under that same Category value, not a separate one). What the CSV format doesn't solve on its own is the part that's specific to endurance racing: one Number can be legitimately driven by different people at different times, and the CSV's Driver field only holds one name at a time.
WEC photographers deliver to manufacturer teams, championship media, and wire services who expect the driver name in the metadata to match who was actually driving in that frame — not just which car it was. A car number is permanent for the season, but a caption crediting the wrong driver for a stint is the kind of error a team's PR office notices immediately, and it undermines trust in every other caption in that delivery.
In this sport specifically
A WEC entry runs 24 hours split into multiple driver stints, with length varying by fuel strategy and team plan, and each pit stop can swap the driver as well as the tires. Three classes (Hypercar, LMP2, GT3) share the track with car numbers that can look similar at distance or under night lighting, so the CSV's Category field matters as much as the Number field for telling two similarly-numbered cars in different classes apart. None of this is visible in a single frame — a photo shows a car number and a class, not a driver's identity — so the CSV workflow has to be built around stints, not around a single list for the whole race.
Where it shows up
Car #7 starts the race with its lead driver, hands over to the second driver after the first pit stop three hours in, and a third driver takes the final stint for the last five hours. · very common
A single start-list CSV built before the race only has one name against #7. Photos from the second and third stints get matched to the Number correctly but carry the wrong Driver name unless the CSV is updated and the affected folder is re-tagged against the corrected version.
A GT3 car and a Hypercar entry happen to run similar car numbers, and at night, under headlights, the class-colored door plate that would normally disambiguate them is harder to read. · common
If your CSV lists both numbers but the Category field isn't populated or the frame doesn't show the class clearly, the match comes back ambiguous and gets flagged for review rather than assigned confidently to the wrong class.
A driver is injured or ill partway through the event and a reserve takes over their stints for the rest of the race, a change that isn't always reflected in the pre-race entry list. · occasional
Photos from the reserve's stints get tagged with the outgoing driver's name until you update the CSV for the affected session and re-run that batch.
A team publishes its stint schedule (who's driving during which hour) separately from the entry list, and the two documents use slightly different name formats for the same driver. · common
Cross-referencing your photo timestamps against the stint schedule to figure out which CSV to use for which folder becomes a manual step, and a name-format mismatch between the two sources can cause you to build the CSV with the wrong spelling.
Traditional approaches, and why they fall short
One start-list CSV built from the pre-race entry list and used for the whole 24 hours
Minimal setup, but every driver change after the first stint makes it wrong · Correct only for the first stint of each car; wrong for every subsequent driver change
Treats a car number as a fixed driver for the whole race, which endurance racing specifically breaks. Doesn't distinguish which stint a photo belongs to.
Tag everything by car number only and add the driver name by hand afterward using your own timing notes
Hours of manual cross-referencing against the team's stint schedule, spread across a 24-hour delivery window · Depends entirely on how carefully you tracked stint timing during the race, and fatigue over 24 hours makes errors more likely late in the event
Doesn't scale to thousands of photos across dozens of cars, and any gap in your own stint notes leaves photos unattributed.
Wait for the team or series to publish a post-race stint report and re-tag everything against it
Report often isn't available until well after the checkered flag, well past same-day or interim delivery windows · High once the report exists, since it's the authoritative record
Doesn't help with interim deliveries during the race, which is when agencies and teams want driver-accurate captions most.
How RaceTagger handles it
RaceTagger matches the car number it detects against the Number column in your CSV, and cross-checks the car's visual class (Hypercar, LMP2, or GT3) against the Category column you fill in — that class cross-check is what keeps two similarly-numbered cars in different classes from being confused. What it can't do is look at a driver's helmet or suit through a windscreen and tell you which of the car's credited drivers is behind the wheel — that identity isn't visible in the frame. The practical fix is the same one that works for any roster that changes mid-event: build a CSV per stint or per session, with the Driver field set to whoever is actually driving during that window, and tag each folder against the CSV that's correct for it.
Key advantage
The Category cross-check means a Hypercar and a GT3 car sharing a similar number don't get cross-matched even when the class isn't obvious in every frame, because RaceTagger classifies the car's class from the image itself and checks it against your list. Combined with per-stint CSVs, that gets you a car number AND a class match instead of just a number, and it flags the frames where the read is genuinely ambiguous instead of guessing.
- Good conditions
- Daylight frames with a clear door number and a legible class marking match reliably against a current CSV
- Challenging
- Night and twilight frames, headlight glare, and cars where the class-colored door plate is hard to read at distance are more likely to be flagged for review rather than matched automatically
- Worst case
- A car number missing from the CSV for that stint, or two similarly-numbered cars from different classes where neither the number nor the class reads cleanly, comes back unmatched or flagged rather than assigned a guess
Before the race, build your baseline CSV from the official entry list: Number, Driver, Team, Category for every car. As the race runs and stint changes happen, keep a note of which driver is in which car during which window — most photographers already track this for their own shot selection. When you tag a folder of photos from a given window, update the CSV's Driver field for the cars that changed and point RaceTagger at that folder with that version of the CSV. The result is metadata that's correct per stint, which is what interim deliveries during the race actually need, without having to wait for a post-race stint report to tag anything.
Manual vs OCR vs AI vision
| Metric | Manual | Basic OCR | RaceTagger |
|---|---|---|---|
| Handling a driver change mid-race | Cross-reference your own stint notes by hand for every affected photo | No support — reads the number, has no concept of a driver record | Update that stint's CSV Driver field and re-tag the folder against it |
| Telling two similarly-numbered cars in different classes apart | Requires the tagger to recognize livery and class by eye on every frame | Reads the number only, with no class awareness at all | Cross-checks the detected class against your CSV's Category field |
| Delivering driver-accurate captions during the race (not after) | Slow — depends on the tagger's own real-time notes and is easy to fall behind on | Not addressed — no driver matching capability | Tag each stint's folder against that stint's CSV as it's shot |
| Night and glare-affected frames | Reliable if the tagger can see the number and door plate clearly by eye | Accuracy drops sharply with reduced contrast, with no confidence signal | Flagged for review when the number or class reads ambiguously |
| Cars or drivers missing from your CSV (reserves, late substitutions) | Manually identified and added by the tagger when noticed | Returns a number with no driver context either way | Comes back unmatched, flagged for you to add the entry and re-run |
Practical tips
- 1
Build your baseline CSV with Number, Driver, Team, and Category filled in for every entry before the race starts, using the official entry list.
Having the full grid saved locally means you're not dependent on connectivity at the track to get the standard field, and it gives you a version to duplicate and edit as stints change.
- 2
Keep a simple running note of stint changes as you shoot — car number, incoming driver, approximate time — even if it's just a phone note.
That note is what lets you build an accurate per-stint CSV without waiting for an official report, and it's the single biggest driver of accuracy for multi-driver cars.
- 3
Duplicate the baseline CSV per stint window and update only the Driver field for the cars that changed, rather than rebuilding the whole list each time.
Most of the grid doesn't change driver every stint. Editing only what changed is faster and less error-prone than rebuilding from scratch each time you tag a new folder.
- 4
Fill in the Category field for every entry, not just the ones you expect to be ambiguous.
Class confusion tends to show up exactly where you didn't expect it — a car you assumed was easily identifiable at 2 PM can be much harder to read at 2 AM under headlights, so having Category populated for the whole grid means the cross-check is there when you need it.
- 5
For photos where the driver-change flag comes back ambiguous or unmatched, cross-reference your own stint notes before you cross-reference an official report.
Your own timing notes are usually available immediately; official stint reports can lag well past your delivery deadline. Reserve the official report for a final accuracy pass once it's published.
The takeaway
A WEC start-list CSV isn't a one-time download — it's a working document you update every time a stint changes, and RaceTagger's number-plus-class matching is only as accurate as the version of that CSV you tag each folder against.
Match a WEC stint against your own start-list
Try it free. Build a CSV with Number, Driver, Team, and Category from the entry list, update it per stint, and see how the matching and metadata holds up on a real session folder. 1 credit covers 1 photo, and new accounts start with free credits.
Try it free →Questions photographers ask
Does RaceTagger know which driver is in the car right now, or does it just match the car number?
It matches the detected car number — and, where visible, the car's class — against your CSV. It doesn't look at the driver through the windscreen, so it can't tell which of a car's credited drivers is currently in the seat. You supply that by keeping the CSV's Driver field current per stint and tagging each folder against the version that's correct for that window.
How does RaceTagger tell apart two similarly-numbered cars from different WEC classes?
RaceTagger classifies the car's class from the photo as Hypercar, LMP2, or GT3, and cross-checks it against the Category field in your CSV (LMDh-chassis cars belong under Hypercar — that's the class value RaceTagger's classifier actually uses). When the class isn't clearly visible in the frame — common at night or under glare — the mismatch or ambiguity gets flagged for you to confirm rather than guessed.
Do I need a separate CSV for every stint, or can I use one file for the whole 24 hours?
One CSV works fine for cars whose driver doesn't change, but for any car number that swaps drivers mid-race, you'll want to update that entry's Driver field and re-tag the affected folder against the corrected version. Duplicating your baseline CSV and editing only what changed per stint is faster than rebuilding it from scratch.
What happens if a reserve driver isn't in my CSV at all?
The car number still gets detected, but it comes back unmatched against your Driver list until you add the reserve's name to that stint's CSV entry and re-run the affected batch. RaceTagger flags unmatched numbers rather than guessing a name.
Does this work on RAW files straight off the card, and does it replace my usual editor?
Yes — it reads both JPEG and RAW from the embedded preview, so you can tag files right off the card. It's the identification step between the shoot and your editor: it writes car number, class, and driver into standard EXIF, XMP, and IPTC fields, and the tagged files flow into your existing Photo Mechanic, Lightroom, or Capture One workflow.
Keep reading