San Jose Mineta International Airport Real-Time Flight Status API

You need to display, track, and alert on live flights for a specific airport. By the end of this guide, you’ll know how to pull real-time flight status for San Jose Mineta International Airport (IATA: SJC, ICAO: KSJC) with the FlightLabs API, interpret the key fields, and wire them into arrival boards, delay alerts, and schedule syncs.

Why focus on San Jose Mineta International Airport (SJC)

San Jose Mineta International Airport serves the city of San José, California, in the heart of Silicon Valley. Its IATA code is SJC and its ICAO code is KSJC. Developers often track SJC flights to power local travel apps, airport displays, and logistics tools supporting Bay Area operations.

What the Real-Time Flight Status endpoint returns

Use the Real-time Flight Tracking endpoint to fetch current status, times, terminal and gate information, and the last known position. The base endpoint is:

• Real-time Flight Tracking: https://www.goflightlabs.com/real-time

The response includes a single-flight or multi-flight payload depending on your query and plan. The example below shows a single flight structure with the fields you will typically use:

{
    "success": true,
    "data": {
        "flight": {
            "iata": "AA123",
            "icao": "AAL123",
            "number": "123",
            "status": "en-route",
            "departure": {
                "airport": "SEA",
                "scheduled": "2024-03-20T10:00:00Z",
                "actual": "2024-03-20T10:05:00Z",
                "terminal": "N",
                "gate": "C11"
            },
            "arrival": {
                "airport": "SJC",
                "scheduled": "2024-03-20T12:15:00Z",
                "estimated": "2024-03-20T12:28:00Z",
                "terminal": "B",
                "gate": "12"
            },
            "position": {
                "latitude": 39.8729,
                "longitude": -98.7372,
                "altitude": 35000,
                "speed": 495,
                "heading": 270
            }
        }
    }
}

Notes:

• Times are in ISO 8601 UTC (Z) by default. Convert to America/Los_Angeles when displaying local SJC times.
• Use status for live state, scheduled/actual/estimated for timing, and terminal/gate for the passenger experience layer.
• position gives the last reported latitude/longitude, altitude, speed, and heading for mapping or ETA logic.
• Field presence can vary by data source and plan. Always null-check optional fields like terminal, gate, and position.

How to request SJC flight status

If you query broadly, filter for SJC on the client by matching arrival.airport === "SJC" or departure.airport === "SJC". Authentication is via API key. The specific delivery method (query parameter or header) depends on your account configuration—see the docs if your environment differs.

curl example

curl -s "https://www.goflightlabs.com/real-time?api_key=YOUR_API_KEY"

This returns real-time flight data. In your application, filter the resulting list for records where arrival.airport or departure.airport equals "SJC" to isolate San Jose arrivals or departures.

JavaScript example (Node.js)

import fetch from "node-fetch";

// Fetch live flights and filter for SJC arrivals/departures
async function fetchSJCFlights() {
  const url = "https://www.goflightlabs.com/real-time?api_key=YOUR_API_KEY";
  const res = await fetch(url);
  if (!res.ok) {
    throw new Error(`HTTP ${res.status}`);
  }
  const json = await res.json();

  // Some datasets return data.flight (single) and others data.flights (array).
  // Normalize to an array for filtering.
  const payload = json?.data || {};
  const flights = Array.isArray(payload.flights)
    ? payload.flights
    : payload.flight
    ? [payload.flight]
    : [];

  // Keep flights tied to SJC
  const sjcFlights = flights.filter((f) => {
    const arr = f?.arrival?.airport;
    const dep = f?.departure?.airport;
    return arr === "SJC" || dep === "SJC";
  });

  // Map to the core fields your UI needs
  return sjcFlights.map((f) => ({
    flight_iata: f?.iata,
    status: f?.status,
    dep_airport: f?.departure?.airport,
    dep_scheduled_utc: f?.departure?.scheduled,
    dep_actual_utc: f?.departure?.actual,
    dep_terminal: f?.departure?.terminal,
    dep_gate: f?.departure?.gate,
    arr_airport: f?.arrival?.airport,
    arr_scheduled_utc: f?.arrival?.scheduled,
    arr_estimated_utc: f?.arrival?.estimated,
    arr_terminal: f?.arrival?.terminal,
    arr_gate: f?.arrival?.gate,
    position: f?.position || null
  }));
}

fetchSJCFlights()
  .then((flights) => {
    // Convert or format times to America/Los_Angeles for display as needed.
    console.log(JSON.stringify(flights, null, 2));
  })
  .catch((err) => {
    console.error(err);
  });

The values in the examples are illustrative; rely on actual API responses at runtime. See the FlightLabs documentation for your account’s authentication pattern and additional filters you can apply.

Key fields you will use for SJC integrations

• status: The live state (e.g., en-route). Check for changes to trigger alerts. If a flight is cancelled or diverted, the status reflects that state when provided for your account.
• departure.scheduled / departure.actual: Compare to measure off-block and pushback delays.
• arrival.scheduled / arrival.estimated: Drive ETA countdowns and arrival boards.
• departure.terminal / departure.gate and arrival.terminal / arrival.gate: Populate terminal maps and passenger messaging at SJC.
• position.latitude / longitude / altitude / speed / heading: Plot aircraft on a map and implement ETA-adjustment logic.

Practical use cases at SJC

1) Live arrival boards for SJC

Filter for flights where arrival.airport is "SJC". Sort by arrival.estimated or arrival.scheduled, and display status, terminal, and gate. Convert UTC timestamps into America/Los_Angeles. If arrival.estimated is missing, fall back to arrival.scheduled.

2) Delay and disruption alerts for travelers and ops

Trigger notifications when the delta between departure.actual and departure.scheduled crosses your threshold, or when arrival.estimated drifts from arrival.scheduled. Also watch for changes to status that indicate cancellations, diversions, or returns to gate. Always debounce alerts to avoid duplicates on frequent status updates.

3) Sync schedules for gate planning

Use the Flight Schedules endpoint to pre-populate daily SJC arrivals and departures, and merge with live status and terminal/gate updates from the real-time endpoint. This hybrid approach provides a reliable baseline with up-to-the-minute operations context.

How the endpoints fit together for SJC

Below is a developer-focused comparison of FlightLabs endpoints relevant to building at SJC. It focuses on what the sample payloads show and how you would typically apply them in code.

Polling frequency, caching, and time zones

• Polling: For gate displays and traveler notifications at SJC, poll the real-time endpoint every 30–60 seconds during critical windows (T–60 to T+30 minutes relative to scheduled/estimated times). For lower-urgency views (day-of schedule), polling every 2–5 minutes is often sufficient.
• Caching: Cache immutable records (e.g., schedules beyond today) for hours or days. For mutable fields (status, estimated time, gate), cache for seconds to a minute. Always include ETag/If-Modified-Since headers if supported by your HTTP client stack to minimize bandwidth.
• Time zones: The samples are in UTC (Z). Convert to America/Los_Angeles for SJC-facing UIs and store both UTC and local time to simplify comparisons and sorting.

Handling cancellations, diversions, and missing fields

• Status changes: Monitor status and broadcast updates in your event stream. If a flight becomes cancelled or diverted, reflect that prominently in the UI and downstream notifications. Specific status vocabulary may vary; write your logic to be robust to new or case-variant values.
• Partial data: Terminal and gate fields can be blank for certain flights or data windows. Fallback gracefully: display “TBD” and avoid blocking updates for missing optional fields.
• Codeshares: If codeshare details are available in your plan, treat them as alternate keys to unify duplicate rows on boards. Field availability can vary; consult the docs and null-check in code.

Building SJC arrival and departure views end to end

Step 1: Preload the schedule

Hit the Flight Schedules endpoint to get the base list of flights for your target day. From the sample structure, you can store flight_number, airline.iata, aircraft.type, and the scheduled times. If your UI supports browsing multiple days, segment your queries by small time windows and paginate the results client-side, since pagination parameters vary by account.

Step 2: Layer in real-time status

Call the real-time endpoint and match results to your schedule by flight IATA/number, airline, and scheduled times. Update the live board with status, actual and estimated timestamps, and terminal/gate data. Maintain a small in-memory index (e.g., Map keyed by flight IATA + date) to join quickly at render time.

Step 3: Alert and reconcile

Compare scheduled vs actual/estimated timestamps to detect delays. When thresholds are crossed or gates change, enqueue notifications. For historical reconciliation (post-operation), use the Flight History endpoint to confirm final times and statuses for reporting.

Example workflow for SJC arrivals with realistic data flow

Below is a compact demonstration: fetch real-time data, filter for SJC arrivals, and display passenger-facing fields.

{
  "success": true,
  "data": {
    "flight": {
      "iata": "AA123",
      "icao": "AAL123",
      "number": "123",
      "status": "en-route",
      "departure": {
        "airport": "SEA",
        "scheduled": "2024-03-20T10:00:00Z",
        "actual": "2024-03-20T10:05:00Z",
        "terminal": "N",
        "gate": "C11"
      },
      "arrival": {
        "airport": "SJC",
        "scheduled": "2024-03-20T12:15:00Z",
        "estimated": "2024-03-20T12:28:00Z",
        "terminal": "B",
        "gate": "12"
      },
      "position": {
        "latitude": 39.8729,
        "longitude": -98.7372,
        "altitude": 35000,
        "speed": 495,
        "heading": 270
      }
    }
  }
}

How to use it:

• Use arrival.airport === "SJC" to identify SJC-bound flights.
• Display ETA using arrival.estimated (fallback to arrival.scheduled if absent).
• Show terminal B and gate 12 in the UI, with status “en-route.”
• Render an in-flight map pin using the position object (convert lat/lon to your map provider’s format).

Scheduling and pagination considerations for SJC

• Time windows: Query schedules in small UTC windows (e.g., 2–6 hours) and maintain rolling caches. This reduces payload size and speeds up filtering for SJC.
• Pagination: If your plan returns large arrays, implement client-side pagination using cursors you store (e.g., the last scheduled timestamp you saw). Handle partial pages gracefully: always render as soon as the first page arrives.
• Merging: Join SJC schedules to real-time by flight identifiers and scheduled departure date rather than just the raw flight number to avoid collisions on similarly numbered flights on different days.

Error handling and resiliency

• Transport errors: Implement retries with exponential backoff and jitter on 5xx/timeout.
• Partial success: Check success before reading data. If a subset of flights is missing fields, keep rendering what you have and update incrementally.
• Data freshness: Persist the last-seen payload timestamp and annotate UI elements with “Updated at” in local time. This is useful for control rooms and passenger displays at SJC.

Security and key management

• Store your API key in server-side secrets or environment variables. Do not embed keys in client apps.
• Use your server as a proxy for browser and mobile clients. Implement request quotas and caching to protect your key and control costs.
• Rotate keys regularly and monitor usage. If you need additional filters (e.g., airline or route-specific queries for SJC), review your plan and available query parameters in the docs.

Frequently asked questions

• How often should I poll for SJC live status?
  For arrival/departure boards and alerts, 30–60 seconds during critical windows works well. Outside those windows, 2–5 minutes can be enough.
• Are times returned in local time or UTC?
  The samples show ISO 8601 timestamps in UTC (Z). Convert to America/Los_Angeles for SJC-facing displays.
• How do I handle cancelled or diverted flights?
  Watch the status field. When it indicates a disruption, update your UI and alerts immediately. Be resilient to missing or delayed updates by falling back to the schedule when necessary.
• How do I get schedules for SJC specifically?
  Use the Flight Schedules endpoint and filter in your application by departure.airport === "SJC" or arrival.airport === "SJC". Query in small time windows to reduce payloads and enable smoother pagination.
• Can I map inbound aircraft to SJC?
  Yes. Use position.latitude and position.longitude from the real-time endpoint to place live pins and adjust ETAs, if your UI supports mapping.

Start building with SJC data now. Explore the endpoints and field specifics in the FlightLabs documentation, then Get your FlightLabs API key to begin integrating real-time flight status into your apps and displays.