For timer companies
Timer API
Sync race rosters straight into your timing software, and push bibs, check-ins, and results back. The v1 Timer API gives your company key-authenticated access to registrations (with delta sync and pagination) plus write-back endpoints for bib/chip assignment, race-day check-in, and live results.
20 min read
Every request is authenticated with your company’s API key, a string that looks like rt_ followed by 40 hex characters. Pass it as the X-RT-Api-Key request header:
X-RT-Api-Key: rt_...: the only accepted method. Akeyquery parameter is not accepted (URLs land in proxy/CDN logs and browser history, and this key grants the full roster including minors’ dates of birth. It never belongs in a URL).
Keys are minted from your Timer Dashboard → API tab. Each company holds one key at a time; the plaintext key is shown once, right after you mint or rotate it, and can never be retrieved again. Only a hash is stored. If you lose it, rotate to get a new one.
Keep your key secret
The API is scoped by assignment: a request succeeds only for events where your company is the currently assigned timer for the current edition. When a director renews an event for a new year, the assignment clears and API access clears with it until you’re re-hired. Read responses never include payment or contact data, only the timing-scoped fields listed below. Write endpoints touch exactly the fields they document (bib, chip, check-in, results) and nothing else.
The recommended integration is the classic roster-sync pattern: one full pull, then a light delta poll through race week.
Mint your key
Open your Timer Dashboard → API tab and click Create API Key. Copy the key immediately. It’s shown only once.Discover the race
Call/api/v1/timer/race?race={slug}to get the sub-event ids, registration counts, and the race’s start time.Full pull, page by page
Call/api/v1/timer/registrations?race={slug}. If the response has"hasMore": true, repeat withafter=<nextCursor>untilhasMoreisfalse. Remember theserverTimeof the FIRST page.Poll for changes every ~30 seconds
Call the same endpoint withmodified_after=<lastSync>, wherelastSync= the previous poll’sserverTimeMsminus about 10 seconds (clock-skew + in-flight-write cushion). Apply the returned rows, including"status": "canceled"rows, in order, page untilhasMoreisfalse, then store the newserverTimeMsfor the next poll.Push data back as you work
POST bib/chip assignments to/api/v1/timer/bibs, race-day check-ins to/api/v1/timer/check-in, and live results to/api/v1/timer/results.
Always use serverTime, never your own clock
modified_after from the previous response’s serverTime/serverTimeMs minus ~10 seconds. Your machine’s clock can drift, and writes in flight during your poll can commit with a slightly earlier timestamp. The 10-second overlap means you may re-see a row you already have (harmless; apply it again) but you never miss one.Race metadata plus the event’s sub-events (distances/heats), so your software can discover the sub-event ids to pass to the registrations endpoint, plus live registration and check-in counts.
- race
- Required. The event’s slug, the last part of its Run This URL (
runthis.run/event/{slug}).
curl -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
"https://runthis.run/api/v1/timer/race?race=my-race-5k"Response:
{
"race": {
"slug": "my-race-5k",
"name": "My Race 5K",
"date": "2026-09-12T13:00:00.000Z",
"startDateMs": 1789218000000,
"timeZone": "America/Chicago",
"status": "live"
},
"counts": { "total": 412, "checkedIn": 88 },
"subEvents": [
{ "id": "5k", "name": "5K", "registeredCount": 305 },
{ "id": "1-mile", "name": "1 Mile Fun Run", "registeredCount": 107 }
],
"serverTime": "2026-09-12T12:41:03.512Z",
"serverTimeMs": 1789216863512
}counts.totalis the sum of the sub-events’ current-edition registration counters;counts.checkedInis a live checked-in count (it can benullif the count is momentarily unavailable, never treat that as zero).registeredCountper sub-event comes from the same cached counters the dashboard shows.
The roster feed for an event, paginated, with optional delta sync via modified_after. Full pulls come back in bib-then-name order within each page; delta pages come back in modification order (apply them in order). Rosters change right up to the gun, so responses are marked cache-control: no-store. Run This may answer an identical request from a 5-second server cache (see the rate policy below).
- race
- Required. The event slug, same as above.
- event
- Optional. A sub-event id (from /race) to filter the roster to one distance or heat.
- modified_after
- Optional. Unix milliseconds (e.g.
1789216863512) or an ISO-8601 datetime (e.g.2026-09-12T12:41:03Z). Returns only registrations changed strictly AFTER that instant, including cancellations. This is the delta-sync switch. - limit
- Optional. Page size. Default
500, at most1000(a larger number is treated as 1000). - after
- Optional. The opaque cursor from a prior response’s
nextCursor(or theX-RT-Next-Cursorheader for CSV). A cursor only works with the samemodified_aftermode it was minted in. - includeCanceled
- Optional. Canceled registrations are included by default (each row carries a
statusfield so you can filter). Pass0to drop them. Don’t drop them in a delta poll. The cancellation IS the update your software needs. - checkedInOnly
- Optional. Pass
1(ortrue) to return only athletes who’ve been checked in. - format
- Optional. Pass
csvto get a CSV download instead of JSON. Pagination still applies, see the CSV section.
curl -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
"https://runthis.run/api/v1/timer/registrations?race=my-race-5k&event=5k"Response:
{
"race": {
"slug": "my-race-5k",
"name": "My Race 5K",
"date": "2026-09-12T13:00:00.000Z"
},
"generatedAt": "2026-09-12T12:41:03.512Z",
"serverTime": "2026-09-12T12:41:03.512Z",
"serverTimeMs": 1789216863512,
"count": 2,
"hasMore": false,
"nextCursor": null,
"registrations": [
{
"id": "reg_abc123",
"registrationId": "reg_abc123",
"firstName": "Jane",
"lastName": "Doe",
"gender": "female",
"genderCode": "F",
"dateOfBirth": "1992-04-18",
"age": 34,
"city": "Springfield",
"state": "TN",
"subEventId": "5k",
"subEventName": "5K",
"bibNumber": 101,
"chipNum": "200145",
"checkedIn": true,
"checkedInAt": "2026-09-12T12:05:44.000Z",
"teamName": "Road Runners",
"status": "active",
"lastModified": "2026-09-12T12:05:44.000Z",
"lastModifiedMs": 1789214744000
},
...
]
}- id / registrationId
- The registration id (stable per registrant per edition). Both fields carry the same value, use registrationId in write-back calls.
- firstName / lastName
- The registrant's name.
- gender
- Self-reported gender, as entered at registration:
male,female,non_binaryorprefer_not_to_say(an empty string when it wasn't collected). It stays a word so software that already reads it keeps working. For the one-letter code, readgenderCode. - genderCode
M,ForX(non-binary), or an empty string for prefer not to say or not collected. The same letters as the Timing file and Run This's race results.- dateOfBirth
YYYY-MM-DD, ornullif not collected.- age
- The runner's age the way the race counts it: on race day unless the race picked registration day, December 31 (the USA Triathlon rule) or another date. The same age as the Timing file and Run This's age groups, so you don't have to work it out from
dateOfBirth.nullwithout a date of birth. - city / state
- The registrant's city and US state.
- subEventId / subEventName
- Which distance or heat they're in.
- bibNumber
- Assigned bib, or
nullif none yet. Assign via POST/api/v1/timer/bibsor from the event dashboard. - chipNum
- Chip/transponder number, or
null. Separate from the bib, see Chip vs bib below. - checkedIn / checkedInAt
- Race-day check-in status;
checkedInAtis an ISO timestamp ornull. - teamName
- Team name, or
nullfor individual entries. - status
activeorcanceled. A canceled registration was refunded/released, pull it from your start list.- lastModified / lastModifiedMs
- When the registration last changed (ISO + epoch ms), or
nullon old rows that predate change stamping. This is the fieldmodified_aftercompares against.
Every response carries hasMore and, when there are more pages, an opaque nextCursor. Pass it back as after to get the next page. Keep your other parameters identical between pages.
- Keep paging until
hasMoreisfalse, a filtered page (sub-event filter,checkedInOnly, canceled dropped) can return fewer rows thanlimit, even zero, while more pages still exist. So can any page on a race that has been renewed, because earlier years’ registrations are skipped.hasMoreis the only end-of-data signal; an emptyregistrationsarray is not. - A cursor is mode-specific: one minted on a full pull can’t be used with
modified_after(and vice versa). You get400 cursor-mode-mismatch. - Treat the cursor as an opaque string; its format may change.
Pass modified_after to get only registrations that changed after that instant: new signups, edits, bib/chip changes, check-ins, and cancellations (as status: "canceled" rows). The recommended loop:
- Full pull (no
modified_after), paging untilhasMoreisfalse. Save the first page’sserverTimeMsaslastSync. - Every ~30s:
GET …&modified_after={lastSync − 10000}, paging untilhasMoreisfalse. - Apply returned rows in order (upsert by
registrationId). - Set
lastSyncto the response’sserverTimeMsand repeat.
# First poll after the full pull (serverTimeMs was 1789216863512):
curl -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
"https://runthis.run/api/v1/timer/registrations?race=my-race-5k&modified_after=1789216853512"- Delta pages are ordered oldest-change-first, apply them in order so the last write wins.
- The ~10-second overlap means you may re-receive rows you already applied. Upsert by
registrationIdand this is a no-op. - An empty delta response still returns a fresh
serverTimeMs, use it for the next poll. - Rows that predate change stamping (
lastModified: null) only appear in full pulls. Do one full pull first, then poll.
Bibs and chips are independent fields with different rules:
- Bib (
bibNumber), numeric, unique across the WHOLE event (not just a sub-event). The one exception: a relay team whose bib plan has “relay teams share one bib” enabled, assigning any member propagates the number to every current teammate, and teammates may share it. - Chip (
chipNum). A free-form string (transponder ids are often alphanumeric), up to 16 characters. A chip already worn by a different active registration in the same event is rejected; there is no relay carve-out for chips. To move a chip between runners, clear it from the old runner first (or reassign both in one call. Intra-batch swaps are allowed).
Three POST endpoints let your software push data into Run This. All of them: authenticate with the same API key, require your company to be the assigned timer, are rate-limited (see the rate policy below), and use lenient batch semantics, a bad row gets a per-row error and the rest of the batch still lands. Send JSON with Content-Type: application/json.
Assign or clear bibs and chips, up to 200 assignments per call.
curl -X POST -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"race": "my-race-5k",
"assignments": [
{ "registrationId": "reg_abc123", "bib": 101, "chip": "200145" },
{ "registrationId": "reg_def456", "bib": null },
{ "registrationId": "reg_ghi789", "chip": "200146" }
]
}' \
"https://runthis.run/api/v1/timer/bibs"- bib
- A positive integer (or digit string, ≤16 chars).
nullor""clears the bib. Omit the field to leave it untouched. - chip
- A string, 1–16 chars (numbers accepted and stringified).
nullor""clears. Omit to leave untouched. Each row must include at least one ofbib/chip.
Response:
{
"updated": 4,
"results": [
{ "registrationId": "reg_abc123", "ok": true, "bib": 101, "chip": "200145" },
{ "registrationId": "reg_def456", "ok": true, "bib": null, "chip": null },
{ "registrationId": "reg_ghi789", "ok": false, "bib": 55, "chip": "200099",
"error": "chip-conflict", "wearerRegistrationId": "reg_xyz000" }
]
}updatedcounts every registration written. Relay propagation included, so it can exceed the number of rows you sent.- Each result row echoes the bib/chip the registration wears AFTER the call.
- On
bib-conflict/chip-conflict,wearerRegistrationIdtells you which registration currently wears the number (never their name). A row is all-or-nothing: a bib conflict drops that row’s chip write too. - Per-row errors:
registration-not-found,past-edition-read-only,canceled-registration,bib-conflict,chip-conflict.
Set or undo race-day check-in, up to 200 entries per call. An entry can carry a bib and/or chip too, one call checks the runner in AND assigns their number (same rules as the bibs endpoint).
curl -X POST -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"race": "my-race-5k",
"entries": [
{ "registrationId": "reg_abc123", "checkedIn": true, "bib": 101 },
{ "registrationId": "reg_def456", "checkedIn": false }
]
}' \
"https://runthis.run/api/v1/timer/check-in"Response:
{
"updated": 2,
"results": [
{ "registrationId": "reg_abc123", "ok": true, "checkedIn": true,
"bib": 101, "chip": null },
{ "registrationId": "reg_def456", "ok": true, "checkedIn": false }
]
}- A sub-event that requires a bib at check-in refuses a bibless check-in: the row comes back
ok: falsewith errorbib-required. Send the bib in the same entry (it is applied first) or assign one viaPOST /bibs, then retry. Undo (checkedIn: false) is never gated. - Bib/chip riders are applied BEFORE the check-in. On a distance that does not require bibs, a rejected bib/chip leaves the check-in standing: the row comes back
ok: falsewith the bib error andcheckedInstill set. On a bib-required distance, a rejected bib also blocks the check-in when the runner has no bib on file yet (the row reports the bib error and nocheckedIn). A runner who already has a bib is still checked in. updatedcounts check-in writes (bib propagation writes aren’t double-counted).
Push results for ONE sub-event per call, up to 500 rows. Two modes:
upsert(the default), the live-results pattern. Post finishers as they cross; rows are matched (byregistrationIdfirst, then bybibwithin the sub-event) and merged in place, unmatched rows are created. Omitted fields on a matched row stay untouched.replace, swap the whole sub-event’s results for exactly this payload (rows not re-asserted are deleted; other sub-events untouched).
curl -X POST -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"race": "my-race-5k",
"event": "5k",
"mode": "upsert",
"results": [
{ "registrationId": "reg_abc123", "chipTime": "21:47.3",
"gunTime": "21:52.1", "place": 1 },
{ "bib": 214, "firstName": "Sam", "lastName": "Park",
"gender": "M", "chipTime": 1352400 },
{ "registrationId": "reg_def456", "status": "DNF" },
{ "bib": 388, "splits": [ { "name": "Mile 1", "time": "6:42" } ] }
]
}' \
"https://runthis.run/api/v1/timer/results"- race / event
- Both required.
eventis the sub-event id (from/race). - registrationId / bib
- Each row needs at least one of these. A row with a registrationId is that runner, when the registration is in this year's race and not canceled. A registrationId from an earlier year (past-edition-read-only) or a canceled registration (canceled-registration) skips the row with a per-row error, like one that doesn't exist (registration-not-found). A row with only a bib is the runner who wears that bib in this year's race (in this sub-event first, when two distances use the same number). A bib links no one when two runners still share it, when it's on two rows of one call, or when another row of the call names that runner by registrationId. That row is still saved, just without a runner. On an upsert, a bib never changes the runner a result already has, and never gives a runner a second result in the sub-event. Prefer registrationId. It's stable even when bibs get reassigned.
- chipTime / gunTime
- A time string (
"21:47.3","1:02:15") or a JSON number of milliseconds. A string of digits only ("1307") is read as seconds. - place
- Optional overall place (1 = winner), a positive integer.
- metricValue
- Optional. For sub-events ranked by a manual metric (laps, points, distance) instead of time.
- status
- Optional. dnf, dns, dq or dnq (any case; dsq means dq) for a runner who didn't finish, didn't start, was disqualified or didn't qualify. The row shows that status instead of a time and gets no place. Send finished (or null) to clear it. Left out, a matched row keeps its status and a new row is a finisher. Any other value fails the call with 400 bad-result-N.
- splits
- Optional. The timing mats the runner has crossed, for live tracking:
[{ "name": "Mile 9.8", "time": "1:05:12" }], up to 30 mats, names up to 40 characters. Eachtimeis like chipTime, measured from the runner’s own start. Splits are merged by name with the ones already on file, so you can send each mat as the runner crosses it or every mat each time. A row with splits and nothing else (no time, place, metricValue or status) is a runner still on course: it updates their live tracking and the splits on a result already saved, and never adds them to the results list. Such a row needs a runner (a registrationId, or a bib that links one); otherwise it is skipped withno-runner. Splits show on each runner’s finisher page. - firstName / lastName / gender
- Optional. When a row is linked to a runner (by its registrationId, or by a bib only that runner wears), the registration fills these when omitted and links the runner's Run This account. Gender is saved as M, F or X (non-binary), whether you send M, Male, X or Non-binary (RACE RESULT's "a" counts as X). A linked row also gets the runner's age the way the race counts it, so a distance with Run This age groups places them.
Response:
{
"created": 1,
"updated": 1,
"total": 2,
"published": false,
"runnerNotifications": false,
"onCourse": 1,
"errors": [
{ "index": 2, "registrationId": "reg_bad999",
"error": "registration-not-found" }
]
}- This endpoint never publishes results. Rows land behind the event’s publish gate; you or the director publish from the dashboard.
publishedtells you whether results are currently public. - When the sub-event’s results are already public, runners’ trophies update a few minutes after your last post (and every 10 minutes while you keep posting), not after each one. Only finishers get a trophy from results.
runnerNotificationsis alwaysfalse. Posting or publishing results never emails or notifies runners; race directors write to their runners themselves. The field stays in the response so integrations that read it keep working.onCourseappears when the call had splits-only rows for runners with no result yet: how many were saved for live tracking.- When the sub-event’s results are public on race day, spectators following a runner on the results page see each mat and the finish, and signed-in followers get a push for the newest mat and for the finish. Runners themselves are never notified.
errorsappears only when rows were skipped: aregistrationIdthat doesn’t exist (registration-not-found), is from an earlier year (past-edition-read-only) or was canceled (canceled-registration), or a splits-only row with no runner (no-runner). The rest of the batch still lands.- A concurrent import or re-rank from the dashboard returns
409 results-busy, wait a moment and retry.
Instead of polling for changes, register an HTTPS endpoint and Run This pushes events to your server, usually within a minute of the change. Endpoints are managed from your Timer Dashboard → API tab (company owner only, up to 5 endpoints). Each endpoint picks which events it wants and gets its own signing secret, shown once when you create it, like the API key.
registration.created: a new registration landed (checkout or a director import).registration.updated: a registration changed (director edits, sub-event moves/transfers).registration.canceled: a registration was canceled (refund flow released the spot).checkin.updated: someone was checked in (or a check-in was undone).bib.updated: a bib or chip number was assigned, changed, or cleared from the dashboard or through the API. A bib given automatically at checkout arrives withregistration.created, and a bib cleared when a runner moves to another sub-event arrives withregistration.updated.
Events fire only for races where your company is the currently assigned timer, the same scoping as the rest of the API. There are no result events: changes to results don’t send webhooks.
Each delivery is a POST to your URL with a JSON body and three headers:
POST /your-endpoint HTTP/1.1
Content-Type: application/json
X-RT-Event: checkin.updated
X-RT-Delivery: whd_8Ck2fA91bXw3
X-RT-Signature: sha256=6b1f0c6b6e2f4e...
{
"id": "whd_8Ck2fA91bXw3",
"event": "checkin.updated",
"createdAt": "2026-09-12T12:05:44.000Z",
"race": "my-race-5k",
"data": {
"registrationId": "reg_abc123",
"subEventId": "5k",
"checkedIn": true,
"updatedAtMs": 1789214744000
}
}Payloads are thin references: by design
registrationId and the changed fields. When you receive one, fetch the full row from /api/v1/timer/registrations (a delta poll with your stored serverTimeMs works perfectly). This keeps personal data out of webhook traffic and your request logs.Every delivery (including test pings) is signed with your endpoint’s secret: X-RT-Signature: sha256=<HMAC-SHA256 hex of the raw body>. Recompute it over the raw bytes you received and compare before trusting the payload:
// Node.js
const crypto = require("crypto");
function verify(rawBody, signatureHeader, secret) {
const expected =
"sha256=" +
crypto.createHmac("sha256", secret).update(rawBody, "utf8").digest("hex");
return (
expected.length === signatureHeader.length &&
crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signatureHeader))
);
}- Answer with any 2xx within 10 seconds to acknowledge. Do your processing async, respond first, work later.
- Anything else (non-2xx, timeout, unreachable) is retried with exponential backoff, about 1, 2, 4, then 8 minutes apart. After 5 failed attempts that delivery is dropped, so keep a delta poll running to catch anything you missed.
- An endpoint that fails 20 attempts in a row is automatically disabled; the API tab shows why. Fix your server, send a test ping, then re-enable it there.
- Deliveries can occasionally arrive more than once or out of order, treat them as “something changed, re-sync this registration,” keyed by
registrationId, and you’re naturally idempotent.
Add format=csv to the registrations endpoint and the same roster comes back as a UTF-8 CSV attachment (RFC-4180 quoting) with a header row, importable directly into most timing software:
curl -H "X-RT-Api-Key: rt_YOUR_API_KEY" \
"https://runthis.run/api/v1/timer/registrations?race=my-race-5k&format=csv"registration_id,first_name,last_name,gender,date_of_birth,city,state,sub_event_id,sub_event,bib,checked_in,checked_in_at,team,status,chip,last_modified,gender_code,age
reg_abc123,Jane,Doe,female,1992-04-18,Springfield,TN,5k,5K,101,true,2026-09-12T12:05:44.000Z,Road Runners,active,200145,2026-09-12T12:05:44.000Z,F,34- New columns are only ever APPENDED (never reordered), so positional parsers keep working. The v2 additions are
status,chip, andlast_modified, thengender_codeandageat the end. - Pagination still applies to CSV, check the
X-RT-Has-Moreresponse header and passX-RT-Next-Cursorback asafter. TheX-RT-Server-Timeheader carries the poll timestamp. - A text value that starts with
=,+,-or@(a name typed that way, for example) comes back with an apostrophe in front of it, so a spreadsheet shows it as text instead of running it as a formula. The JSON format returns every value exactly as stored.
Copy-ready commands in your dashboard
curl commands for its registrations feed, for the whole race or one sub-event: everyone, checked-in only, or changes since your last sync. The commands ask for JSON; add &format=csv to the URL for CSV. Each one carries your key in the header if you just created or rotated it, otherwise a YOUR_API_KEY placeholder to replace with your saved key.- Read endpoints (registrations, race): 30 requests/second sustained per key, with a burst allowance of 60. A healthy integration never gets close, poll
modified_afterevery ~30 seconds rather than re-pulling the full roster, and keep to at most 2 concurrent requests. Full re-pulls are for startup and recovery, not the steady-state loop. - Write endpoints (bibs, check-in, results): 10 requests/second sustained per key, with a burst allowance of 20. Batch your rows (up to 200 per bibs/check-in call, 500 per results call) instead of posting one row per request.
- 429 handling: exceeding either limit can return
429 rate-limitedwith aRetry-Afterheader (seconds), wait that long, then retry. Don’t hammer through 429s: a loop that keeps hitting them is polling far faster than the data changes. - Response cache: identical read requests (same key + same query) within 5 seconds may be served from a short server-side cache, the
X-RT-Cacheresponse header sayshitormiss.serverTimeis always fresh, and the 5-second window sits inside the recommended “serverTime− 10s” delta cushion, so the sync recipe is unaffected. - On any
5xxor network error, back off (a few seconds, doubling on repeats) and resume the loop, your next delta poll picks up whatever you missed.
Errors are JSON: { "error": "..." } with a matching HTTP status.
- 400 bad-race
- The
raceparameter is missing or isn’t a valid slug. - 400 bad-modified-after
modified_afterisn’t Unix milliseconds or ISO-8601.- 400 bad-limit / bad-cursor / cursor-mode-mismatch
limitisn’t a number of at least 1, an unreadableaftercursor, or a cursor from the other (full vs delta) mode.- 400 bad-json / no-assignments / no-entries / no-results / bad-assignment-N / bad-entry-N / bad-result-N / missing-event / bad-mode
- A write body failed shape validation (N is the offending row index). Shape problems fail the whole request; data problems (unknown registration, conflicts) are per-row errors in a 200 response.
- 401 missing-or-invalid-key
- No API key was provided, or it doesn't match the rt_ key format.
- 401 unknown-key
- The key doesn't match any company. It may have been rotated or revoked.
- 403 not-the-assigned-timer
- The event exists, but your company isn't its currently assigned timer for the current edition.
- 404 event-not-found / sub-event-not-found
- No event with that slug, or (POST /results only) no sub-event with that id. On GET /registrations, an unknown sub-event id returns an empty roster instead.
- 409 results-busy
- Another writer (a dashboard import or re-rank) holds the results lock. Retry shortly.
- 422 too-many
- A write body exceeded its row cap (200 for bibs/check-in, 500 for results). Split the batch.
- 429 rate-limited
- Rate limit exceeded (reads 30/s burst 60; writes 10/s burst 20). Wait the
Retry-Afterseconds and retry.
The week before
Confirm your key works:GET /racereturns the event with the sub-events you expect. Do a full paginated pull and load the roster into your software.Assign numbers
Push bib + chip assignments viaPOST /bibs(or read the ones assigned in the dashboard). Resolve anybib-conflict/chip-conflictrows,wearerRegistrationIdtells you who holds the number.Start the delta loop
Pollmodified_afterevery ~30 seconds (serverTime − 10s recipe). Late signups, edits, and cancellations flow in automatically, watch forstatus: "canceled"and pull those from your start list.Race morning
Push check-ins as runners arrive (POST /check-in, batched). UsecheckedInOnly=1or the/racecounts to reconcile who’s on course.During and after the race
Post finishers withPOST /resultsinupsertmode as they cross; correct rows by re-posting them. Mark runners who didn’t finish with astatus(dnf, dns, dq or dnq). Usereplacefor a final clean upload. Publishing stays a human decision in the dashboard.
Not listed on Run This yet? Start with Listing your timer company.

