# LGA Flight Board Scraper (`rainminer/lga-flight-board-scraper`) Actor

Scrape full-day departures and arrivals from the official LaGuardia (LGA) 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/lga-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

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## LGA Flight Board Scraper

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

**LGA Flight Board Scraper** exports the full-day **departures and arrivals board** from the official [LaGuardia Airport](https://www.laguardiaairport.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 LGA Flight Board Scraper do?

- **Full-day boards** — Export every departure or arrival listed for a calendar day at LaGuardia (LGA).
- **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 JFK, Newark (EWR), 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 LaGuardia 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 LGA 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 LGA flight board?

| Field | Description |
| --- | --- |
| airport | Airport IATA code (default LGA; also JFK, EWR, 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 LaGuardia airport departures and arrivals

1. Open the Actor in Apify Console.
2. Set **Airport** to `LGA` (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 | `LGA` | 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": "LGA",
  "direction": "departures",
  "localDate": "2026-09-09",
  "timeScheduled": "8:30 AM",
  "timeRevised": "8:45 AM",
  "airlineCode": "DL",
  "airlineName": "Delta Air Lines",
  "flightNumber": 673,
  "counterpartAirport": "ATL",
  "counterpartName": "Atlanta, GA (ATL)",
  "terminal": "C",
  "gate": "C12",
  "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 LaGuardia publish per day?**\
A typical day lists hundreds of departures and 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 laguardiaairport.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 JFK or Newark?**\
Yes. Set `airport` to `JFK`, `EWR`, 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: [laguardiaairport.com](https://www.laguardiaairport.com/)

# Actor input Schema

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

Port Authority airport IATA code. This Actor defaults to LGA but also supports JFK, EWR, 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": "LGA",
  "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": "LGA",
    "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/lga-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": "LGA",
    "direction": "departures",
    "maxItems": 5,
    "onlyDisrupted": False,
    "deduplicateCodeshares": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/lga-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": "LGA",
  "direction": "departures",
  "maxItems": 5,
  "onlyDisrupted": false,
  "deduplicateCodeshares": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rainminer/lga-flight-board-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/lga-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/6hWZXOebBpBZNTPWB/builds/OZCq9EUm4WrnliWUj/openapi.json