Phoenix Sky Harbor Flight Status Scraper

Export Phoenix Sky Harbor flight status records from the airport's public flight board. Get current arrivals and departures with airline, flight number, city, scheduled and estimated times, terminal, gate, status, and bag claim. The Actor turns the changing PHX board into typed dataset rows for traveler tools, recurring checks, spreadsheets, and airport-operations feeds.

What can this Actor do?

• Export current Phoenix Sky Harbor arrivals, departures, or both.
• Filter by airline, city or airport code, flight number, status, and scheduled date.
• Capture scheduled, estimated, actual, and chock times when the source provides them.
• Capture terminal, gate, flight status, and arrival bag claim.
• Limit output for focused checks or save a larger board snapshot.
• Feed scheduled Apify Tasks, webhooks, spreadsheets, databases, and alerting workflows.

This Actor reads the same public structured data used by the Sky Harbor flight page. It does not require an airline account, browser, or proxy.

Who is it for?

Travel application developers can add a current PHX status feed without parsing a visual table.

Airport and ground-operations teams can schedule snapshots and track gate, terminal, arrival, or departure changes.

Traveler-service teams can filter one airline, flight, or city and connect the dataset to notifications.

Data analysts can export repeatable board snapshots to JSON, CSV, Excel, Google Sheets, or a warehouse.

Automation builders can combine scheduled runs with Apify webhooks to trigger downstream processing.

Why use this flight status scraper?

The public board is designed for interactive lookup. This Actor provides integration-ready records with stable field names and explicit null values.

It validates the upstream response before saving data. Transient network, rate-limit, and server errors receive bounded retries. An invalid response fails the run instead of silently returning a misleading empty dataset.

Filters are applied before charging and saving, so you only pay per qualifying flight record.

What Phoenix flight data is extracted?

Field	Meaning
flightId	Source flight-record identifier
direction	arrival or departure
airline	Airline name shown by PHX
airlineCode	Airline code when available
flightNumber	Combined airline code and number
city	Origin for arrivals or destination for departures
airportCode	Parsed origin or destination airport code
scheduledTime	ISO 8601 scheduled timestamp
scheduledDisplay	Schedule text shown by the airport
estimatedTime	Current estimate when available
actualTime	Actual time when available
chockTime	Aircraft chock time when available
terminal	PHX terminal number when assigned
gate	Gate when assigned
status	Current human-readable status
statusCode	Compact source status code
bagClaim	Arrival bag-claim carousel when assigned
codeShares	Code-share entries from the source
fetchedAt	Time the board snapshot was fetched
sourceUrl	Public Sky Harbor flight-page URL

How to scrape Phoenix Sky Harbor flights

1. Open the Actor in Apify Console.
2. Choose arrivals, departures, or both.
3. Add optional airline, city, flight-number, status, or date filters.
4. Set the maximum number of qualifying flights.
5. Click Start.
6. Open the Dataset tab to inspect or export the records.
7. Optionally create a schedule and webhook for recurring monitoring.

For a broad first run, use:

{
  "direction": "both",
  "maxItems": 100
}

Input parameters

Parameter	Type	Default	Description
direction	string	both	arrivals, departures, or both
airline	string	—	Case-insensitive airline-name filter
city	string	—	Case-insensitive city or airport-code filter
flightNumber	string	—	Number with or without airline code
status	string	—	Status text such as arrived or delayed
scheduledDate	string	—	Date in YYYY-MM-DD format
maxItems	integer	100	Save 1–2,000 qualifying records

All text filters use case-insensitive partial comparisons. For example, Southwest matches Southwest Airlines, and DEN matches a city label ending in (DEN).

Useful input examples

Current PHX arrivals

{
  "direction": "arrivals",
  "maxItems": 25
}

Southwest departures

{
  "direction": "departures",
  "airline": "Southwest",
  "maxItems": 25
}

Arrived-flight monitoring feed

{
  "direction": "arrivals",
  "status": "arrived",
  "maxItems": 100
}

One route or airport

{
  "direction": "both",
  "city": "DEN",
  "maxItems": 100
}

One flight number

{
  "direction": "both",
  "flightNumber": "4077",
  "maxItems": 10
}

Output example

A real run produces records shaped like this:

{
  "sourceUrl": "https://www.skyharbor.com/flights/",
  "flightId": "3374717",
  "direction": "departure",
  "airline": "Southwest Airlines",
  "airlineCode": "WN",
  "flightNumber": "WN4077",
  "city": "HOUSTON",
  "airportCode": "HOU",
  "scheduledTime": "2026-08-29T05:00:00Z",
  "scheduledDisplay": "5:00 AM",
  "estimatedTime": "5:06 AM",
  "actualTime": "5:23 AM",
  "chockTime": "5:08 AM",
  "terminal": "4",
  "gate": "D17",
  "status": "Departed",
  "statusCode": "DP",
  "bagClaim": null,
  "codeShares": [],
  "fetchedAt": "2026-08-29T14:08:07.568Z"
}

Times such as estimatedTime are display values from the airport board. Fields not yet assigned by the airport are returned as null.

How much does it cost to export Phoenix Sky Harbor flight status?

The Actor uses pay-per-event pricing:

• a $0.005 start fee per run;
• a tiered flight record fee for each qualifying row saved.

At the BRONZE tier, a flight record is $0.000872. That makes 25 records about $0.0268 including the start fee, 100 records about $0.0922, and 1,000 records about $0.877. Higher-volume subscription tiers receive lower per-record prices. Apify platform usage is included in pay-per-event pricing; no proxy is required by the current implementation.

Only accepted flight records are charged. A valid zero-result filter incurs the one-time start event but no flight-record events.

Recurring monitoring and alerts

The Actor returns a snapshot; it does not keep running after completion or send alerts by itself. Use an Apify schedule to run it at your chosen interval.

A common workflow is:

1. Schedule a filtered arrival or departure input.
2. Send the completed-run webhook to Make, Zapier, n8n, or your API.
3. Compare flightId, status, gate, terminal, and time fields with the previous snapshot.
4. Notify users only when a relevant value changes.

Store prior snapshots in your own database or automation destination when change history matters.

Export and integrations

The default dataset supports JSON, CSV, XML, RSS, and Excel-compatible downloads through Apify. You can also:

• send results to Google Sheets;
• stream dataset items into a warehouse;
• trigger an Apify webhook when a run finishes;
• call the Actor from JavaScript or Python;
• expose it to AI agents through Apify MCP.

Keep flightId together with scheduledTime when deduplicating recurring snapshots.

Run with the Apify API

Replace YOUR_TOKEN with an Apify API token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~phoenix-sky-harbor-flight-status/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"direction":"arrivals","maxItems":25}'

Fetch dataset items using the defaultDatasetId returned by the run.

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/phoenix-sky-harbor-flight-status').call({
  direction: 'departures',
  airline: 'Southwest',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/phoenix-sky-harbor-flight-status").call(
    run_input={"direction": "both", "city": "DEN", "maxItems": 100}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Use with Apify MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/phoenix-sky-harbor-flight-status"

Use the same JSON block for Claude Desktop, Cursor, and VS Code:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/phoenix-sky-harbor-flight-status"
    }
  }
}

Example prompts:

• “Export the 25 latest Phoenix Sky Harbor arrivals.”
• “Find current Southwest departures from PHX and show gate changes.”
• “Return arrived flights from Denver for my operations report.”

Reliability and retries

Each run makes one request to the public structured flight feed. Network failures, HTTP 429 responses, and temporary server errors are retried with bounded exponential backoff, up to three attempts total.

The Actor validates JSON content type and required source fields. A blocked, malformed, or changed endpoint causes a failed run rather than incomplete output presented as success. No unmeasured residential fallback is enabled.

Limits and freshness

• The airport controls board coverage, update timing, and field assignments.
• The public feed exposes its current schedule window, not arbitrary flight history.
• scheduledDate only filters dates already present in that current window.
• Gate, terminal, estimate, status, bag claim, and code shares can be missing or change after a run.
• The Actor does not include aircraft position, fares, parking, terminal maps, or airport-delay advisories.
• A scheduled Task creates snapshots; it does not guarantee instant change notification.

Always check fetchedAt when freshness matters.

Empty results

A run can correctly return zero rows when no current board record matches every filter. Try these checks:

1. Remove scheduledDate; it may be outside the source's current window.
2. Use a partial airline name such as Southwest.
3. Use an airport code or part of a city name.
4. Remove the status filter because statuses change throughout the day.
5. Switch direction to both.

A zero-result run is different from an upstream failure: invalid upstream data fails with an error in the run log.

Troubleshooting

The run says the date is invalid. Use an actual calendar date formatted exactly as YYYY-MM-DD.

A gate or bag claim is null. The airport has not assigned or published that field for the flight.

The flight number does not match. Try the numeric part only, or the combined source form such as WN4077.

A known flight is absent. It may fall outside the public board's current schedule window, or the airline may be showing a code-share number not present as the primary record.

The Actor failed after retries. Inspect the run log. A temporary source outage can be retried later; a response-schema error may indicate that Sky Harbor changed its feed.

Legality and responsible use

This Actor extracts public operational flight information. Use it in accordance with applicable laws, Sky Harbor's terms, Apify's terms, and your downstream providers' rules.

Do not represent a snapshot as an official safety, boarding, or emergency instruction. Travelers should confirm time-sensitive details with Phoenix Sky Harbor and the operating airline. Avoid excessive scheduling and collect only the fields needed for your workflow.

Related Actors

• FAA NAS Status & Airport Delays Scraper — pair PHX flight rows with broader FAA airport advisory and delay context.
• Ryanair Flight Fares and Cheapest Routes — use when the job is Ryanair fare and route monitoring rather than Phoenix airport status.

These Actors provide different records and are not substitutes for the current Sky Harbor flight board.

FAQ

Does this Actor provide live aircraft positions?

No. It exports the status and schedule fields published on the Phoenix Sky Harbor flight board.

Can it export historical flights?

No. It filters the source's current schedule window and does not claim a historical archive.

Can I monitor one airline or route?

Yes. Combine direction with airline, city, or flightNumber and schedule the input.

Does it need a proxy?

No. The current implementation uses a public JSON feed directly without a proxy or browser.

Are all fields always available?

No. Estimates, actual times, gates, terminals, bag claims, and code shares depend on what the airport has assigned and published.

How do I avoid duplicate notifications?

Persist the previous snapshot and compare stable identifiers plus status, gate, terminal, and time fields before sending an alert.

Is this an official Phoenix airport product?

No. It is an independent Apify Actor that structures public data from the Phoenix Sky Harbor flight board.