Houston IAH added to real-time flight status API — quality sample 28 Sep 2026

You need reliable, real-time flight status for George Bush Intercontinental Airport (IAH) that you can plug into your app without building your own data pipeline. By the end of this article, you’ll know how to query FlightLabs’ Real-Time Flight Status for IAH, interpret the response (status, terminals, gates, times, delays, codeshares), handle time zones and UTC, manage polling and caching, and build a robust integration that won’t break on cancellations or diversions.

What “Real-Time Flight Status” Covers at IAH

George Bush Intercontinental Houston (IAH) is now fully available in the Real-Time Flight Status endpoint. You can track departures and arrivals for IAH, search by airline and flight number, and access live position data when available. Typical consumer experiences include mobile trip tracking, airport FIDS (Flight Information Display Systems), dispatch/ops dashboards, and proactive traveler notifications.

At a high level, this endpoint returns:

• Flight progress: flight_status and timestamps (scheduled, estimated, actual)
• Airport ops details: terminals, gates, baggage claims when provided
• Codeshares: quickly identify marketing vs. operating flight
• Live telemetry: latitude, longitude, speed, altitude, direction when available
• Filtering: by arrival/departure IATA (IAH), by flight IATA, and pagination for schedule-sized queries

Before you start, create an API key. It’s free to get started: Register. You can also browse endpoint details in the Documentation or test requests in the MCP.

Endpoint Overview and Parameters

This section summarizes the Real-Time Flight Status retrieval patterns developers use for IAH. If a specific filter or sub-field is not mentioned here, consult the Documentation for your workspace.

• HTTP method: GET
• Base endpoint: https://api.goflightlabs.com/flights
• Authentication: access_key query parameter

Common query parameters you will use for IAH:

• access_key: your API key
• arr_iata: set to IAH to get inbound flights to George Bush Intercontinental Houston
• dep_iata: set to IAH to get outbound flights from George Bush Intercontinental Houston
• flight_iata: filter by an airline flight number (e.g., UA1256)
• limit, offset: paginate through larger result sets (e.g., full bank departures/arrivals)

Key response fields you will parse:

• flight_status: scheduled, active, landed, cancelled, diverted, or delayed (string)
• airline: details about the carrier, including iata code
• flight: identifiers, including iata and codeshared
• departure and arrival objects: airport, iata, scheduled, estimated, actual, terminal, gate, delay
• live: live position telemetry when available (latitude, longitude, altitude, speed, direction)
• pagination: limit, offset, count, total

Notes on time handling:

• Scheduled, estimated, and actual timestamps are typically returned as ISO 8601 in UTC. Convert to America/Chicago (IAH local) for displays. Keep UTC internally for comparisons.
• Delays are generally in minutes. Do not assume seconds unless documented in your response.

IAH: Arrivals and Departures Queries

Use arr_iata=IAH to watch inbound traffic, useful for curbside pickup apps or baggage carousels, and dep_iata=IAH for outbound status, useful for gate screens and push notifications. You can combine with limit/offset for pagination over a wave of flights, and flight_iata to zero in on a single service.

Copy-Paste cURL: Live IAH Arrivals

The following request fetches recent and upcoming arrivals into IAH. Replace YOUR_API_KEY with your key.

curl -s "https://api.goflightlabs.com/flights?access_key=YOUR_API_KEY&arr_iata=IAH&limit=10"

Illustrative JSON response below. Field names and structure mirror what your integration should expect; values are examples for demonstration.

{
"pagination": {
"limit": 10,
"offset": 0,
"count": 10,
"total": 324
},
"data": [
{
"flight_status": "active",
"airline": {
"name": "United Airlines",
"iata": "UA"
},
"flight": {
"number": "1256",
"iata": "UA1256",
"icao": "UAL1256",
"codeshared": null
},
"departure": {
"airport": "Denver International",
"iata": "DEN",
"scheduled": "2026-09-28T18:05:00Z",
"estimated": "2026-09-28T18:10:00Z",
"actual": "2026-09-28T18:12:00Z",
"terminal": "B",
"gate": "B32",
"delay": 7
},
"arrival": {
"airport": "George Bush Intercontinental",
"iata": "IAH",
"scheduled": "2026-09-28T20:54:00Z",
"estimated": "2026-09-28T20:47:00Z",
"actual": null,
"terminal": "C",
"gate": "C14",
"baggage": "C6",
"delay": 0
},
"live": {
"latitude": 30.366,
"longitude": -95.612,
"altitude": 10668,
"speed": 232,
"direction": 164
}
},
{
"flight_status": "landed",
"airline": {
"name": "American Airlines",
"iata": "AA"
},
"flight": {
"number": "2403",
"iata": "AA2403",
"icao": "AAL2403",
"codeshared": null
},
"departure": {
"airport": "Dallas/Fort Worth International",
"iata": "DFW",
"scheduled": "2026-09-28T19:05:00Z",
"estimated": "2026-09-28T19:03:00Z",
"actual": "2026-09-28T19:04:00Z",
"terminal": "A",
"gate": "A21",
"delay": 0
},
"arrival": {
"airport": "George Bush Intercontinental",
"iata": "IAH",
"scheduled": "2026-09-28T20:15:00Z",
"estimated": "2026-09-28T20:12:00Z",
"actual": "2026-09-28T20:10:00Z",
"terminal": "A",
"gate": "A8",
"baggage": "A2",
"delay": 0
},
"live": null
},
{
"flight_status": "cancelled",
"airline": {
"name": "Spirit Airlines",
"iata": "NK"
},
"flight": {
"number": "1012",
"iata": "NK1012",
"icao": "NKS1012",
"codeshared": null
},
"departure": {
"airport": "Orlando International",
"iata": "MCO",
"scheduled": "2026-09-28T17:40:00Z",
"estimated": null,
"actual": null,
"terminal": "A",
"gate": null,
"delay": null
},
"arrival": {
"airport": "George Bush Intercontinental",
"iata": "IAH",
"scheduled": "2026-09-28T19:55:00Z",
"estimated": null,
"actual": null,
"terminal": null,
"gate": null,
"baggage": null,
"delay": null
},
"live": null
},
{
"flight_status": "diverted",
"airline": {
"name": "Delta Air Lines",
"iata": "DL"
},
"flight": {
"number": "1179",
"iata": "DL1179",
"icao": "DAL1179",
"codeshared": null
},
"departure": {
"airport": "Hartsfield-Jackson Atlanta International",
"iata": "ATL",
"scheduled": "2026-09-28T18:15:00Z",
"estimated": "2026-09-28T18:20:00Z",
"actual": "2026-09-28T18:23:00Z",
"terminal": "S",
"gate": "T5",
"delay": 8
},
"arrival": {
"airport": "George Bush Intercontinental",
"iata": "IAH",
"scheduled": "2026-09-28T20:05:00Z",
"estimated": null,
"actual": null,
"terminal": null,
"gate": null,
"baggage": null,
"delay": null
},
"live": {
"latitude": 30.320,
"longitude": -96.455,
"altitude": 1829,
"speed": 140,
"direction": 315
}
}
]
}

Field highlights you’ll need:

• flight_status: drive UI labels and edge-case handling (cancelled, diverted).
• departure/arrival.scheduled, estimated, actual: base your countdown and ETA/ETD on estimated when present, fall back to scheduled, and finalize with actual.
• departure/arrival.terminal, gate, baggage: show passengers where to go; handle nulls gracefully.
• delay: minutes (commonly) to display or calculate knock-on effects.
• flight.codeshared: when populated, show the operating carrier; for IAH you’ll see this frequently on partner routes.
• live: only present for some flights; when available, you can draw position on a map near IAH.

JavaScript Example: Polling Departures from IAH

This example fetches upcoming IAH departures, shows how to read key fields, and demonstrates a simple polling loop with basic caching. Replace YOUR_API_KEY.

async function fetchIahDepartures(limit = 20, offset = 0) {
const url = new URL("https://api.goflightlabs.com/flights");
url.searchParams.set("access_key", "YOUR_API_KEY");
url.searchParams.set("dep_iata", "IAH");
url.searchParams.set("limit", String(limit));
url.searchParams.set("offset", String(offset));

const res = await fetch(url.toString(), { method: "GET" });
if (!res.ok) throw new Error("Network error " + res.status);
const json = await res.json();
return json;
}

function summarizeFlight(item) {
const status = item.flight_status;
const airline = item.airline?.iata || item.airline?.name || "UNK";
const number = item.flight?.iata || item.flight?.number || "N/A";

const dep = item.departure || {};
const arr = item.arrival || {};

// Prefer estimated if available, else scheduled; all times generally UTC
const etd = dep.estimated || dep.scheduled || null;
const eta = arr.estimated || arr.scheduled || null;

// Surface critical operational details
return {
status,
flight: `${airline} ${number}`,
dep_iata: dep.iata,
dep_terminal: dep.terminal || null,
dep_gate: dep.gate || null,
etd_utc: etd,
arr_iata: arr.iata,
arr_terminal: arr.terminal || null,
arr_gate: arr.gate || null,
eta_utc: eta,
delay_min: dep.delay ?? arr.delay ?? 0,
codeshare: item.flight?.codeshared || null
};
}

// Simple in-memory cache keyed by page
const cache = new Map();

async function pollDepartures(page = 0) {
const key = `page-${page}`;
const cached = cache.get(key);
const now = Date.now();

// Cache for 30 seconds
if (cached && now - cached.ts < 30000) {
return cached.data;
}

const limit = 20;
const offset = page * limit;

const json = await fetchIahDepartures(limit, offset);
const pageData = (json.data || []).map(summarizeFlight);
cache.set(key, { ts: now, data: pageData });
return pageData;
}

// Example usage:
pollDepartures(0)
.then(list => {
console.table(list.slice(0, 5));
})
.catch(err => console.error(err));

Implementation notes:

• Keep all timestamps in UTC internally. Convert to America/Chicago only for UI output, ensuring correct CT/CDT transitions.
• For flight_status cancelled or diverted, immediately suppress countdowns and show a high-visibility message. For diverted, consider replacing the planned IAH arrival gate with “—”.
• If codeshared is set, append “operated by …” in your UI. For loyalty members at IAH, the operating carrier can change lounge and check-in flows.
• Use pagination (limit/offset) to avoid loading entire departure banks in one call; many FIDS rotate pages every few seconds.

Integrating IAH into Apps and Displays

Time zones and UTC

Flight timestamps are typically ISO 8601 UTC. For IAH, convert to America/Chicago for user-facing times and signage. When comparing scheduled vs. estimated vs. actual, do comparisons in UTC to avoid DST glitches. Always store the original UTC value; compute local time per user locale or per-airport convention.

Polling frequency and caching

• Active flights: poll every 15–30 seconds while flight_status is active to keep ETAs tight.
• Scheduled flights: 30–120 seconds suffices until within the hour of departure/arrival.
• Static displays: cache pages for 30 seconds and rotate paginated lists; invalidate cache on gate changes or major ETA deltas if your UI listens for them.

When implementing polling, de-duplicate by flight.iata across pages so you don’t cause flicker in your FIDS rows as pagination cycles.

Handling edge cases at IAH

• Cancelled: flight_status=cancelled. Clear terminal/gate, show “Cancelled,” and stop polling frequently for that flight unless you maintain a history panel.
• Diverted: flight_status=diverted. If live telemetry is present, show the diversion path. Arrival fields for IAH may be null or stale in a diversion scenario.
• Delayed: use departure.delay or arrival.delay to flag row-level delay badges. Rely on estimated where present; it supersedes scheduled for ETD/ETA.
• Codeshares: if flight.codeshared is populated, display both marketing (flight.iata) and operating flight. For gate/terminal, follow the operating carrier’s assignment at IAH.

Field Reference You’ll Actually Use

Filtering and Pagination Patterns for IAH

Filters keep payload sizes small and UIs fast. For airport views, start with arr_iata=IAH or dep_iata=IAH. For traveler-specific views, filter by flight_iata to follow a single flight. For full-bank FIDS at IAH, use pagination and page rotation.

Practical paging loop

• Set limit to a practical page size (e.g., 50–100 based on your layout and device size).
• Begin at offset=0, render the page, then advance offset by limit every rotation.
• If pagination.total changes significantly, reset to offset=0 to avoid stale pages.

Combine paging with a timestamp-based cache to minimize redundant reflows. Only re-render a page if a gate, terminal, or ETA changed since the last paint.

Production Checklist for IAH Real-Time Status

• Authentication: pass access_key via query string for every request.
• Resilience: back off on HTTP errors; retry with jitter to avoid thundering herds.
• Time math: store and compare in UTC; format in America/Chicago for IAH displays.
• Display logic:
  • estimated overrides scheduled; actual finalizes the event.
  • cancelled: suppress gates, show “Cancelled”.
  • diverted: drop IAH arrival resource hints; keep explanatory banner.
  • codeshared: include “operated by …” when present.
• Pagination: render limit-sized pages; don’t fetch more than needed.
• Caching: 15–60 seconds, depending on the UI and SLA for freshness.
• Telemetry: only render live map if data.live exists for the item.

Single-Flight Tracking at IAH

For notifications and trip cards, target a flight by its flight_iata (e.g., UA1256). This cuts response data to a single item and simplifies your logic.

curl -s "https://api.goflightlabs.com/flights?access_key=YOUR_API_KEY&flight_iata=UA1256"

In your handler:

• Read flight_status; if active, schedule tighter polling (15–30s).
• Use arrival.estimated for ETA; if null, use arrival.scheduled.
• If terminal/gate changes at IAH, send a high-priority push update.
• If live is present, attach a compact map preview in the card.

Security, Rate Use, and Operations

Keep your access_key secure—do not embed it client-side for public apps without a proxy or token exchange. For backend jobs (airport signage, ops tools), restricting outbound traffic to the FlightLabs domain and using environment variables for secrets is a clean approach.

Design polling that scales gracefully. Increase intervals during off-peak or when a flight is cancelled. Avoid parallel calls for the same offset page; collapse duplicate in-flight requests. If you need additional fields or filters, verify them in the Documentation.

Troubleshooting IAH Integrations

• Missing gate/terminal: field may be null upstream. Show “—” and do not infer the terminal.
• ETA jumps: prioritize arrival.estimated and reflect changes clearly; do not smooth over large deltas silently.
• Time confusion: if a flight seems “late” by your logic, confirm you’re comparing UTC-to-UTC.
• Duplicate listings: de-duplicate by flight.iata; collapse codeshare variants if your UI displays by operating flight.
• Pagination drift: when pagination.total changes, refresh your carousel from offset=0.

FAQ

How do I display local time for IAH while keeping backend logic stable?
Store and compare scheduled/estimated/actual timestamps in UTC. Only format to America/Chicago on output. This prevents DST and offset issues in logic while keeping IAH times user-friendly.

What’s the best way to know if a flight to IAH is really delayed?
Use arrival.estimated when present; this supersedes arrival.scheduled. Show arrival.delay (minutes) if available. If both estimated and delay are missing, treat the flight as on schedule.

How often should I poll the Real-Time Flight Status endpoint?
For airport screens or operations, 30–60s for general boards; tighten to 15–30s only for flights with flight_status=active or near gate close. Cache results at least 15–30s to reduce redundant loads.

How do I handle cancellations and diversions for IAH displays?
When flight_status is cancelled, clear gates/terminals and show “Cancelled.” For diverted, remove IAH arrival gate/terminal and display a diversion message. Do not attempt to synthesize missing fields.

Can I fetch both arrivals and departures for IAH in one request?
Use separate requests for arr_iata=IAH and dep_iata=IAH. This keeps responses predictable and simplifies pagination and caching strategies per board.

Ready to integrate IAH into your real-time flight status workflow? Get your key and start testing in minutes: Register. Explore all filters and fields in the Documentation and test calls directly in the MCP.