TakeoffTimer APItakeofftimer.com ↗
Get real-time TSA security wait times, hourly forecasts, PreCheck checkpoint status, and FAA delay alerts for US airports via the TakeoffTimer API.
What is the TakeoffTimer API?
The TakeoffTimer API exposes 1 endpoint — get_wait_times — that returns 10+ structured fields covering live TSA security wait times, hourly wait forecasts, PreCheck checkpoint open/closed status, and FAA delay alerts for any US airport. Pass a 3–4 character IATA or FAA airport code and get back current wait minutes, a labeled hourly forecast array, per-terminal checkpoint status, and active ground stop or delay alerts.
curl -X GET 'https://api.parse.bot/scraper/56f8ce6c-2fdc-44c8-b1c3-cdcbcbc0818b/get_wait_times?airport_code=BUR' \ -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 takeofftimer-com-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: TakeoffTimer SDK — get live TSA wait times for any US airport."""
from parse_apis.takeofftimer_com_api import TakeoffTimer, AirportNotFound
client = TakeoffTimer()
# Fetch live wait times for Burbank airport
try:
bur = client.airport_waits.get(airport_code="BUR")
print(bur.airport_code, bur.available)
if bur.current_wait:
print(bur.current_wait.standard_minutes, bur.current_wait.standard_description)
for slot in bur.hourly_forecast[:3]:
print(slot.timeslot, slot.wait_minutes)
except AirportNotFound as e:
print("not found:", e.airport_code)
print("exercised: airport_waits.get")
Returns live TSA security wait times, hourly wait forecasts, PreCheck checkpoint open/closed status, and FAA delay alerts for a given US airport. Data refreshes every few minutes from TSA sources. Airports without TSA data return available=false with empty forecast and checkpoint fields.
| Param | Type | Description |
|---|---|---|
| airport_coderequired | string | 3-4 letter IATA/FAA airport code (e.g. 'BUR', 'LAX', 'JFK'). |
{
"type": "object",
"fields": {
"source": "data source identifier",
"available": "whether TSA wait time data is available for this airport",
"faa_alerts": "object with ground_stops, ground_delays, and general_delays sub-objects",
"airport_code": "IATA/FAA code of the airport",
"current_wait": "object with current standard wait minutes, description, PreCheck availability, and timestamp; null if unavailable",
"hourly_forecast": "array of hourly wait time predictions with timeslot label, wait_minutes, and hour number",
"precheck_checkpoints": "object mapping terminal names to checkpoint names and their open/closed status"
},
"sample": {
"data": {
"source": "tsawaittimes",
"available": true,
"faa_alerts": {
"ground_stops": {
"reason": "",
"end_time": ""
},
"ground_delays": {
"reason": "",
"average": ""
},
"general_delays": {
"trend": "",
"reason": ""
}
},
"airport_code": "BUR",
"current_wait": {
"timestamp": "2026-07-23T20:02:37.484Z",
"standard_minutes": 9,
"precheck_available": true,
"standard_description": "8 minutes and 30 seconds"
},
"hourly_forecast": [
{
"hour": 4,
"timeslot": "4 am - 5 am",
"wait_minutes": 12.3
},
{
"hour": 5,
"timeslot": "5 am - 6 am",
"wait_minutes": 13.1
}
],
"precheck_checkpoints": {
"Terminal MAIN": {
"Checkpoint 1": "Open"
}
}
},
"status": "success"
}
}About the TakeoffTimer API
What the API Returns
The get_wait_times endpoint accepts a single required parameter, airport_code, which takes any standard IATA or FAA 3–4 letter code (e.g. BUR, LAX, JFK). The response includes a top-level available boolean that signals whether TSA wait data exists for that airport. When available is true, the current_wait object provides the current standard lane wait in minutes, a human-readable description, a PreCheck availability flag, and a timestamp for the reading. Data refreshes every few minutes.
Hourly Forecasts and Checkpoint Status
The hourly_forecast array delivers per-hour wait time predictions, each entry carrying a timeslot label, wait_minutes, and an hour number — useful for displaying a day-view chart or surfacing the lightest travel window. The precheck_checkpoints object maps terminal names to individual checkpoint names and their current open/closed status, letting you show travelers exactly which lanes are operational before they leave for the airport.
FAA Alerts
The faa_alerts object contains three sub-objects — ground_stops, ground_delays, and general_delays — drawn from FAA advisory data. These alerts are airport-scoped, so you can surface active ground stops or ATCSCC delay programs alongside the TSA wait information in a single API call. Airports without TSA coverage return available: false with empty hourly_forecast and precheck_checkpoints fields rather than an error, so your integration handles unsupported airports gracefully.
The TakeoffTimer API is a managed, monitored endpoint for takeofftimer.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when takeofftimer.com 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 takeofftimer.com 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?+
- Show departing passengers the current TSA wait time and PreCheck lane status on a flight itinerary page.
- Build a 'best time to arrive' widget using the
hourly_forecastarray to surface low-wait windows. - Alert travelers to active FAA ground stops or ground delays at their departure airport before they leave home.
- Display per-terminal PreCheck checkpoint open/closed status in an airport map or wayfinding app.
- Power a dashboard that monitors TSA wait trends across multiple US airports simultaneously.
- Send push notifications when current wait minutes exceed a user-defined threshold at their home airport.
- Enrich travel booking confirmation emails with real-time security wait and delay advisory data.
| 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 TakeoffTimer have an official developer API?+
What does `get_wait_times` return for an airport that has no TSA data?+
available: false. The current_wait field is null, hourly_forecast is an empty array, and precheck_checkpoints is an empty object. FAA alert fields are still included. This means your code never needs to handle a hard error for unsupported airports — just check available before rendering wait data.How current is the wait time data?+
current_wait object includes a timestamp field you can use to determine data age. The underlying source refreshes every few minutes, so the data is near-real-time but not guaranteed to reflect instantaneous conditions at the checkpoint.