letour APIletour.fr ↗
Access Tour de France stage classification data via the letour.fr API. Get rider finish order, bib numbers, team names, finish times, and time gaps per stage.
What is the letour API?
The letour.fr API exposes individual stage classification data from the official Tour de France website through 1 endpoint, returning up to the full peloton of classified riders per stage. The get_stage_classification endpoint delivers each rider's rank, bib number, name, team affiliation, finish time, and time gap to the stage winner, alongside the stage distance and total classified rider count.
curl -X GET 'https://api.parse.bot/scraper/3296b188-86ac-440d-aff3-2edb91f161de/get_stage_classification?year=2026&stage_number=11' \ -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 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 Stage Classification API — bounded, re-runnable."""
from parse_apis.letour_fr_api import TourDeFrance, StageNumber, StageNotFound
client = TourDeFrance()
# Fetch the individual stage classification for Stage 2
stage = client.stage_classifications.get(stage_number=StageNumber.STAGE_2)
print(f"Stage {stage.stage_number} ({stage.distance}) — {stage.total_riders} riders classified")
# Iterate over the top finishers
for rider in stage.riders[:5]:
print(f" {rider.rank}. #{rider.bib_number} {rider.rider_name} ({rider.team}) — {rider.finish_time}, gap: {rider.time_gap}")
# Handle a stage that may not have data (e.g., Team Time Trial)
try:
ttt_stage = client.stage_classifications.get(stage_number=StageNumber.STAGE_1)
print(f"\nStage 1: {ttt_stage.total_riders} riders classified")
except StageNotFound as exc:
print(f"Stage 1 not available: {exc}")
print("exercised: stage_classifications.get / StageNumber enum / RiderResult field access / StageNotFound error handling")
Retrieve the individual stage classification (classement de l'étape) for a specific Tour de France stage. Returns the arrival order for that stage only (not the cumulative general classification), including each rider's rank, bib number, name, team, finish time, and time gap to the stage winner. Stages that are Team Time Trials have no individual stage classification and return an empty riders list with an explanatory message. Future stages with no results yet also return empty.
| Param | Type | Description |
|---|---|---|
| year | string | Tour de France edition year. Currently only 2026 data is available on the live site. |
| stage_numberrequired | string | Stage number (1 to 21). |
{
"type": "object",
"fields": {
"year": "integer",
"riders": "array of rider result objects",
"distance": "string — stage distance in km (e.g. '168.5 km')",
"stage_number": "integer",
"total_riders": "integer — number of classified riders"
},
"sample": {
"data": {
"year": 2026,
"riders": [
{
"rank": 1,
"team": "UAE TEAM EMIRATES XRG",
"time_gap": null,
"bib_number": "2",
"rider_name": "I. DEL TORO",
"finish_time": "03h 40' 01''"
},
{
"rank": 2,
"team": "UAE TEAM EMIRATES XRG",
"time_gap": null,
"bib_number": "1",
"rider_name": "T. POGACAR",
"finish_time": "03h 40' 01''"
},
{
"rank": 3,
"team": "RED BULL - BORA - HANSGROHE",
"time_gap": null,
"bib_number": "21",
"rider_name": "R. EVENEPOEL",
"finish_time": "03h 40' 01''"
}
],
"distance": "168.5 km",
"stage_number": 2,
"total_riders": 183
},
"status": "success"
}
}About the letour API
What the API Returns
The get_stage_classification endpoint returns the arrival order for a single Tour de France stage — not the cumulative general classification (GC). Each call targets a specific edition and stage number. The response includes a riders array of result objects covering rank, bib number, rider name, team, finish time, and time gap to the winner, plus top-level fields for year, stage_number, distance (e.g. '168.5 km'), and total_riders.
Inputs and Coverage
Two parameters control the query: stage_number (required, 1–21) and year (optional string). Currently, only 2026 edition data is available via the live source. Requesting a stage that hasn't yet been raced will return no rider results. There is no pagination parameter — all classified riders for the requested stage are returned in a single response.
Data Scope and Limitations
The endpoint covers the individual stage classification only. Cumulative standings such as the general classification, points classification (maillot vert), best climber (maillot à pois), or young rider classification are not part of the response. Stage distance is provided as a formatted string rather than a numeric value. Time gaps are expressed relative to the stage winner, not to the overall race leader.
The letour API is a managed, monitored endpoint for letour.fr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when 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 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 the full finish order for any Tour de France stage on a sports dashboard using
ridersrank and finish time fields. - Calculate time gaps between specific riders within a stage using the per-rider gap field from the response.
- Build stage-by-stage performance tracking for a specific rider by querying
get_stage_classificationacross all 21 stages. - Populate a team performance view by grouping results from the
teamfield within a stage'sridersarray. - Enrich a cycling fantasy platform with real stage result data including bib numbers and finish times.
- Monitor which riders finished within the same time group by comparing time gap values across the classified rider list.
- Archive historical stage classification data for a given Tour de France edition by iterating stage numbers 1 through 21.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does letour.fr have an official developer API?+
What does the `get_stage_classification` endpoint return, and how does it differ from the general classification?+
Does the API cover multiple Tour de France editions?+
Does the API include the points classification, best climber standings, or team classification?+
Is there any known quirk in the stage distance field?+
distance field is returned as a formatted string (e.g. '168.5 km') rather than a bare numeric value. If you need to do arithmetic on stage distances, you will need to strip the unit suffix before parsing.