RATP APIratp.fr ↗
Real-time traffic status and disruption data for all Paris RER lines (A–E) via the RATP API. Get line status, severity levels, and active disruption details.
What is the RATP API?
This API provides real-time traffic status and disruption data for Paris RER lines A through E across 3 endpoints. The get_all_traffic endpoint returns a severity level and status summary for every line, while get_rer_a_traffic returns granular disruption objects for RER A including location, type, and French-language message text. get_disruptions surfaces only lines currently experiencing issues, making it straightforward to build alert-based workflows.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/1ad63560-1ceb-42b7-9a05-919a3c27b106/get_rer_a_traffic' \ -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 ratp-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: RATP Traffic API — monitor Paris RER line status and disruptions."""
from parse_apis.ratp_traffic_api import Ratp, TrafficStatus, TrafficUnavailable
client = Ratp()
# Get overview of all RER lines — each has a severity level and summary.
for line in client.linetraffics.list(limit=5):
print(line.line, line.level, line.summary)
# Get detailed RER A status including disruption list.
rer_a = client.rerastatuses.get()
print(rer_a.line, rer_a.status, rer_a.status_summary)
for d in rer_a.disruptions[:3]:
print(d.type, d.location, d.message[:80])
# List active disruptions across all lines — only lines with issues appear.
try:
disruption = client.linedisruptions.list(limit=1).first()
if disruption:
print(disruption.line, disruption.status, disruption.details[:100])
except TrafficUnavailable as exc:
print(f"traffic unavailable: {exc}")
print("exercised: linetraffics.list / rerastatuses.get / linedisruptions.list")
Get real-time traffic status for RER A, including current status classification and detailed disruption information. Returns the line status (normal, planned_works, perturbed, critical), a French-language summary, and an array of active disruptions with type, location, and message. No input parameters required.
No input parameters required.
{
"type": "object",
"fields": {
"line": "string, always 'RER A'",
"status": "string indicating traffic condition (normal, planned_works, perturbed, critical)",
"disruptions": "array of disruption objects each with type, location, and message strings",
"status_summary": "string with French-language summary of the current status"
},
"sample": {
"data": {
"line": "RER A",
"status": "planned_works",
"disruptions": [
{
"type": "Travaux",
"message": "Jusqu'au 20 juin inclus, le week-end, le trafic est interrompu entre Nanterre – Préfecture et Cergy – Le Haut en raison de travaux. Bus de remplacement.",
"location": "Poissy / Nanterre – Préfecture"
}
],
"status_summary": "perturbation prévue"
},
"status": "success"
}
}About the RATP API
Endpoints and Response Shape
The get_all_traffic endpoint returns a traffic array covering all five RER lines. Each object includes a line name, a summary string describing current conditions, and a numeric level field where 0 means normal service and higher integers indicate increasing disruption severity. This makes it suitable for dashboards that need a quick overview without parsing long message strings.
The get_rer_a_traffic endpoint focuses exclusively on RER A and returns a status field classified as one of four values: normal, planned_works, perturbed, or critical. It also returns a disruptions array where each object includes type, location, and message fields, plus a status_summary string in French that mirrors the official RATP wording.
Disruptions Across All Lines
The get_disruptions endpoint aggregates active and upcoming perturbations across all RER lines. Critically, it only returns lines that have a non-normal status — if all lines are running normally, the response includes a message string to that effect. When disruptions exist, each item in the disruptions array carries line, status, details, and planned_disruptions fields, giving both current and forward-looking disruption context.
Coverage and Language Notes
All three endpoints cover only RATP-operated RER lines (A through E). Status summaries and disruption messages are returned in French, which reflects the source data. There are no input parameters on any endpoint — each call returns the current live state at the time of the request.
The RATP API is a managed, monitored endpoint for ratp.fr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ratp.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 ratp.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?+
- Build a commuter alert app that notifies users when
levelexceeds 0 on any RER line fromget_all_traffic. - Display a live status board for RER A using the
statusclassification anddisruptionsarray fromget_rer_a_traffic. - Filter only affected lines using
get_disruptionsto reduce noise in a transit monitoring dashboard. - Show planned maintenance windows to travellers by reading
planned_disruptionsfrom theget_disruptionsresponse. - Correlate RER disruption events with ridership or delay data by timestamping
get_all_trafficresponses at regular intervals. - Surface French-language
status_summarytext directly in a Paris-focused travel assistant or chatbot.
| 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 RATP have an official developer API?+
What does `get_disruptions` return when all lines are running normally?+
get_disruptions returns a message string indicating no disruptions are found. The disruptions array is absent or empty in that case. When issues exist, each entry in the array includes line, status, details, and planned_disruptions for that specific line.Does the API cover Paris Métro lines or only RER lines?+
Can I filter `get_all_traffic` results to a specific RER line?+
line name in the returned traffic array is required. You can fork this API on Parse and revise it to add a line parameter to the endpoint.