# JFK Flight Board Scraper (`rainminer/jfk-flight-board-scraper`) Actor

Scrape full-day departures and arrivals from the official JFK airport flight board. Export scheduled and revised times, airlines, terminals, gates, and live status for every movement on a chosen date. No login required.

- **URL**: https://apify.com/rainminer/jfk-flight-board-scraper.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.67 / 1,000 flight board rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## JFK Flight Board Scraper

[![JFK Airport departures flight board](https://api.apify.com/v2/key-value-stores/vdPXKRB5smkRYhtEV/records/jfk-flight-board-scraper-banner.jpg)](https://apify.com/rainminer/jfk-flight-board-scraper)

**JFK Flight Board Scraper** exports the full-day **departures and arrivals board** from the official [JFK Airport](https://www.jfkairport.com/) website. Pick a date, choose departures, arrivals, or both, and download every scheduled movement with airline, terminal, gate, and live status — no login and no API key.

Run it on the **Apify platform** to schedule daily board snapshots, export JSON/CSV/Excel, monitor delays, and integrate flight rows via API.

### What can JFK Flight Board Scraper do?

- **Full-day boards** — Export every departure or arrival listed for a calendar day at JFK.
- **Live status** — Capture On Time, Delayed, Cancelled, Departed, and other statuses as shown on the official board.
- **Revised times** — Get both scheduled and revised departure/arrival times when the airport publishes updates.
- **Gate and terminal** — Pull terminal and gate assignments for pickup planning and airport operations tools.
- **Departures, arrivals, or both** — Run one direction or scrape both boards in a single Actor run.
- **Date selection** — Target today or any future/past date the airport board still lists (America/New\_York local date).
- **Sibling airports** — The same input also supports Newark (EWR), LaGuardia (LGA), and Stewart (SWF) Port Authority boards.
- **Disruption filter** — Optionally export only Delayed or Cancelled flights.
- **Codeshare deduplication** — Optionally collapse duplicate codeshare rows that share the same time, route, terminal, and gate.
- **No-code export** — Download JSON, CSV, Excel, or HTML from the dataset tab, or call the Actor via API.
- **Apify platform** — Schedule hourly runs, set webhooks on delayed flights, and keep a historical archive of board snapshots.

### Why scrape the JFK airport flight board?

- **Pickup and meeting tools** — Show travelers the latest gate, terminal, and revised time for the flight they are meeting.
- **On-time performance analytics** — Build OTP dashboards from official airport status snapshots over time.
- **Travel apps** — Enrich itinerary screens with live airport-board data without negotiating airline feeds.
- **Operations monitoring** — Track cancellation and delay spikes across a full day of JFK movements.
- **Competitive intelligence** — Compare airline punctuality on specific routes using public board data.
- **Historical archives** — Schedule daily runs to build a time series of how a flight’s status evolved.

### What data can you extract from the JFK flight board?

| Field | Description |
| --- | --- |
| airport | Airport IATA code (default JFK; also EWR, LGA, SWF) |
| direction | `departures` or `arrivals` |
| localDate | Board date in America/New\_York (`YYYY-MM-DD`) |
| timeScheduled | Scheduled local time as shown on the board |
| timeRevised | Revised local time when published; `null` if unchanged |
| airlineCode | IATA airline code |
| airlineName | Marketing airline name |
| flightNumber | Flight number |
| counterpartAirport | Destination IATA (departures) or origin IATA (arrivals) |
| counterpartName | Destination or origin city/name |
| terminal | Terminal identifier |
| gate | Gate assignment; `null` when not published |
| status | Board status (e.g. On Time, Delayed, Cancelled, Departed) |
| scrapedAt | UTC timestamp when the row was collected |

### How to scrape JFK airport departures and arrivals

1. Open the Actor in Apify Console.
2. Set **Airport** to `JFK` (default).
3. Choose **Direction** — departures, arrivals, or both.
4. Optionally set **Date** (`YYYY-MM-DD` in New York local time); leave blank for today.
5. Set **Max Items per Direction** — use a high number (e.g. 3000) for a full-day export, or keep the default `5` for a quick test.
6. Run the Actor and download results from the **Dataset** tab.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| airport | string | `JFK` | Port Authority airport: JFK, EWR, LGA, or SWF |
| direction | string | `departures` | `departures`, `arrivals`, or `both` |
| date | string | today (NY) | Local board date `YYYY-MM-DD` |
| maxItems | integer | `5` | Max rows per direction |
| onlyDisrupted | boolean | `false` | Export only Delayed or Cancelled rows |
| deduplicateCodeshares | boolean | `false` | Dedupe codeshare rows by time, route, terminal, and gate |
| proxyConfiguration | object | no proxy | Optional Apify Proxy settings |

### Output

Each dataset row is one flight movement on the official airport board:

```json
{
  "airport": "JFK",
  "direction": "departures",
  "localDate": "2026-09-09",
  "timeScheduled": "8:30 AM",
  "timeRevised": "8:45 AM",
  "airlineCode": "DL",
  "airlineName": "Delta Air Lines",
  "flightNumber": 673,
  "counterpartAirport": "LAX",
  "counterpartName": "Los Angeles, CA (LAX)",
  "terminal": "4",
  "gate": "B32",
  "status": "Delayed",
  "scrapedAt": "2026-09-09T12:00:00.000Z"
}
```

### Pricing

Pay per flight row exported to the dataset. Status, gate, and terminal data are included with each row — there is no separate status charge.

### FAQ

**How many flights does JFK publish per day?**\
A typical day lists roughly 2,300+ departures and a similar volume of arrivals. Set `maxItems` high enough to capture the full board, or schedule daily runs and store snapshots over time.

**Does this scrape airline websites?**\
No. Data comes from the official Port Authority airport flight board — the same public board travelers see on jfkairport.com.

**Are codeshares deduplicated?**\
By default, each marketing flight listed on the board is exported as its own row. Enable **Deduplicate Codeshares** to keep one row per scheduled movement (same time, route, terminal, and gate).

**Do I need a proxy?**\
No. The official board is reachable with direct HTTP requests; proxy defaults to off.

**Can I scrape Newark or LaGuardia?**\
Yes. Set `airport` to `EWR`, `LGA`, or `SWF` to use the same Actor against other Port Authority airports.

### Integrations

Export dataset items via the Apify API, connect webhooks for automated alerts, or schedule recurring runs to build a historical flight-board archive.

### Image Credit

Image credit: [jfkairport.com](https://www.jfkairport.com/)

# Actor input Schema

## `airport` (type: `string`):

Port Authority airport IATA code. This Actor defaults to JFK but also supports EWR, LGA, and SWF.

## `direction` (type: `string`):

Scrape departures, arrivals, or both boards for the selected date.

## `date` (type: `string`):

Local airport date in YYYY-MM-DD format (America/New\_York). Defaults to today.

## `maxItems` (type: `integer`):

Maximum number of flight rows to export per direction (departures and arrivals are counted separately when direction is both).

## `onlyDisrupted` (type: `boolean`):

When enabled, export only rows whose status is Delayed or Cancelled (case-insensitive).

## `deduplicateCodeshares` (type: `boolean`):

When enabled, keep one row per airport, direction, date, scheduled time, counterpart airport, terminal, and gate (first row wins).

## `proxyConfiguration` (type: `object`):

Proxy settings. The official airport board works without a proxy.

## Actor input object example

```json
{
  "airport": "JFK",
  "direction": "departures",
  "maxItems": 5,
  "onlyDisrupted": false,
  "deduplicateCodeshares": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "airport": "JFK",
    "direction": "departures",
    "maxItems": 5,
    "onlyDisrupted": false,
    "deduplicateCodeshares": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/jfk-flight-board-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "airport": "JFK",
    "direction": "departures",
    "maxItems": 5,
    "onlyDisrupted": False,
    "deduplicateCodeshares": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/jfk-flight-board-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "airport": "JFK",
  "direction": "departures",
  "maxItems": 5,
  "onlyDisrupted": false,
  "deduplicateCodeshares": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rainminer/jfk-flight-board-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/jfk-flight-board-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bRlQdFu3Vxvox1GGt/builds/C4cWzAw1PRCKnRSxP/openapi.json