letour APIracecenter.letour.fr ↗
Access live Tour de France rider positions, stage details, and general classification standings via the Race Center API. 3 endpoints, real-time GPS group data.
What is the letour API?
The Race Center API provides 3 endpoints for Tour de France data: live rider group positions with GPS coordinates and time gaps, per-stage route and timing details via get_stage_info, and overall general classification standings after each stage. All 21 stages of the current edition are covered, and position data updates every few seconds during active racing.
curl -X GET 'https://api.parse.bot/scraper/0984e08b-bfe8-4fd6-b955-866c5133a406/get_stage_info?stage_number=10' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace racecenter-letour-fr-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Tour de France Race Center SDK — bounded, re-runnable; every call capped."""
from parse_apis.racecenter_letour_fr_api import TourDeFrance, StageNotFound
client = TourDeFrance()
# List all stages in the current Tour edition
for stage in client.stages.list(limit=3):
print(stage.stage_number, stage.departure_city, "→", stage.arrival_city, stage.length_km, "km")
# Get live positions for the current stage (stage 10)
current = client.stage(10)
for group in current.live_positions(limit=3):
print(group.name, f"gap={group.gap_seconds}s", f"speed={group.speed_kmh}km/h")
for rider in group.riders[:2]:
print(f" bib {rider.bib}: {rider.firstname} {rider.lastname} ({rider.nationality})")
# Get general classification after stage 9
try:
gc = client.stage(9).classification()
print(gc.classification_type, f"({len(gc.rankings)} riders)")
for entry in gc.rankings[:3]:
print(f" #{entry.position} {entry.firstname} {entry.lastname} gap={entry.gap_seconds}s")
except StageNotFound as e:
print(f"Stage not found: {e.stage_number}")
print("exercised: stages.list / stage.live_positions / stage.classification")
Returns stage details for the current Tour de France edition. When stage_number is supplied, returns that single stage; when omitted, returns all 21 stages. Each stage includes route (departure/arrival cities), distance, scheduled times, type code, and cancellation status.
| Param | Type | Description |
|---|---|---|
| stage_number | integer | Stage number (1-21). Omit to retrieve all stages. |
{
"type": "object",
"fields": {
"stages": "array of stage objects with route, timing, and type details"
},
"sample": {
"stages": [
{
"date": "2026-07-14T00:00:00+02:00",
"type": "HMG",
"end_time": "17:14:00",
"timezone": "Europe/Paris",
"length_km": 166.6,
"start_time": "13:15:00",
"arrival_city": "Le Lioran",
"is_cancelled": false,
"stage_number": 10,
"departure_city": "Aurillac"
}
]
}
}About the letour API
Stage Information
get_stage_info returns route and logistics data for Tour de France stages. Supply a stage_number (1–21) to retrieve a single stage, or omit it to get all 21 stages at once. Each stage object includes departure and arrival cities, total distance, scheduled start and finish times, a type code (e.g. flat, mountain, time trial), and a cancellation status flag. This endpoint is useful for building stage schedules or pre-race display layers.
Live Rider Positions
get_live_positions accepts a required stage_number and returns the current state of the race as an array of rider groups. Each group carries GPS coordinates, current speed, distance remaining to the finish, time gap to the leader, jersey indicators (e.g. yellow, polka dot), and the list of riders within that group. The response also includes an ISO 8601 timestamp so clients can detect stale data. Outside of active racing the groups array is empty.
General Classification
get_general_classification returns the GC standings as they stand after a specified stage. Each entry in the rankings array includes the rider's position, cumulative race time, and gap to the overall leader, plus any bonuses or penalties applied. The classification_type field identifies the ranking category returned. Data is available once timing for the requested stage has been published, so it reflects both intermediate and final results.
The letour API is a managed, monitored endpoint for racecenter.letour.fr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when racecenter.letour.fr changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official racecenter.letour.fr API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Display a live race tracker map by plotting GPS coordinates from
get_live_positionsrider groups. - Show time gaps between breakaway groups and the peloton during a stage using the gap field.
- Build a stage-by-stage schedule page using departure/arrival cities and distances from
get_stage_info. - Alert fans when the yellow jersey changes group using jersey indicator fields in live position data.
- Render a GC leaderboard that updates after each stage finishes using
get_general_classification. - Filter upcoming mountain stages by type code from
get_stage_infoto focus on climbing data. - Track cumulative time differences between top GC contenders across multiple stages.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does letour.fr offer an official public developer API?+
What does `get_live_positions` return when no stage is actively racing?+
groups array in the response is empty. The timestamp field is still present, so you can check response freshness. Live group data including GPS coordinates, speed, and time gaps only populates during active stage racing.Does the API cover classifications other than the general classification, such as the points or mountains jersey standings?+
get_general_classification, which returns a classification_type field, but dedicated endpoints for the points classification (green jersey) or mountains classification (polka dot jersey) are not included. You can fork this API on Parse and revise it to add endpoints targeting those specific classification types.How current is the general classification data after a stage finishes?+
get_general_classification endpoint notes that data is available once intermediate or final timing for the requested stage has been published. There may be a delay between a stage finishing and official timing being released, particularly if protests or time penalties are under review.