# VATSIM Live Network Scraper (`parseforge/vatsim-live-network-scraper`) Actor

Pull the live VATSIM flight simulation network in one pass. Online pilots arrive with callsign, position, altitude, ground speed, heading, transponder, and filed route, plus controllers with frequency and facility. Filter by airport or callsign for live maps and event tracking.

- **URL**: https://apify.com/parseforge/vatsim-live-network-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛩️ VATSIM Live Network Scraper

> 🚀 **Pull the entire live VATSIM network in one run.** Around 1,800 online pilots and 190 controllers, each as a clean flat record with position, flight plan, and frequency.

> 🕒 **Last updated:** 2026-06-05 · **📊 24 fields** per pilot record · live snapshot · global coverage

VATSIM is the global online flight simulation network where thousands of virtual pilots and air traffic controllers fly and control together in real conditions. This Actor reads the official VATSIM Data v3 feed and turns the current live snapshot into a structured table you can analyze, map, or pipe into your own tools.

Coverage is worldwide and live. Every connected pilot and controller present in the feed at run time is available, with no account, key, or login required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Flight sim community builders, ATC trainers, VATSIM event organizers, aviation data hobbyists, dashboard makers | Live traffic maps, event load monitoring, network analytics, ATC staffing views, training dashboards |

### 📋 What the VATSIM Live Network Scraper does

It fetches the live VATSIM Data v3 snapshot and maps each entry to one flat record.

- **Pilots mode** returns every connected pilot with callsign, member name, CID, latitude, longitude, altitude, ground speed, heading, transponder, and a flattened flight plan (aircraft, departure, arrival, alternate, cruise speed, planned altitude, route, remarks).
- **Controllers mode** returns every online controller with callsign, frequency, facility, rating, visual range, and logon time.
- Optional filters narrow results by callsign text, and for pilots by departure or arrival airport.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `mode` | string (select) | Yes | `pilots` for online flights, `controllers` for online ATC. Default `pilots`. |
| `callsign` | string | No | Keep only records whose callsign contains this text. Example `DLH`. |
| `departure` | string | No | Pilots only. Keep flights departing this ICAO airport. Example `EGLL`. |
| `arrival` | string | No | Pilots only. Keep flights arriving this ICAO airport. Example `KJFK`. |
| `maxItems` | integer | No | Cap on records returned. Free plan is limited to 10. |

Example 1, all online pilots:

```json
{
  "mode": "pilots",
  "maxItems": 50
}
````

Example 2, flights arriving at London Heathrow:

```json
{
  "mode": "pilots",
  "arrival": "EGLL",
  "maxItems": 25
}
```

> ⚠️ **Good to Know:** The feed is a live snapshot. Records reflect who is connected at the moment the run starts, so two runs minutes apart will differ. Pilots who have not filed a flight plan will have empty departure, arrival, and route fields.

### 📊 Output

Each pilot record contains these fields:

| Field | Description |
|---|---|
| 🛩 `callsign` | Pilot callsign on the network |
| 🆔 `cid` | VATSIM member ID |
| 👤 `name` | Member display name |
| 📍 `latitude` / `longitude` | Live aircraft position |
| 📈 `altitude` | Current altitude in feet |
| 💨 `groundspeed` | Ground speed in knots |
| 🧭 `heading` | Heading in degrees |
| 📟 `transponder` | Squawk code |
| ✈️ `aircraft` | Aircraft type from the flight plan |
| 🛫 `departure` / 🛬 `arrival` | Flight plan airports (ICAO) |
| 🗺 `route` | Filed route string |
| 📝 `remarks` | Flight plan remarks |
| 🕒 `scrapedAt` | Run timestamp |
| ❌ `error` | Null on success |

Three real sample pilot records from a live run:

```json
{ "callsign": "GEC8442", "cid": 1752278, "name": "Max EDDL", "latitude": 28.74657, "longitude": -103.74676, "altitude": 35045, "groundspeed": 491, "heading": 309, "transponder": "1000", "aircraft": "MD11", "departure": "SBGL", "arrival": "KPHX", "plannedAltitude": "28000" }
```

```json
{ "callsign": "QFA001", "cid": 1891533, "name": "Anthony Carney EGNT", "latitude": -17.02844, "longitude": 136.09202, "altitude": 43203, "groundspeed": 493, "heading": 143, "transponder": "5131", "aircraft": "A359", "departure": "EGLL", "arrival": "YSSY", "plannedAltitude": "33000" }
```

```json
{ "callsign": "QFA63", "cid": 1470520, "name": "Harikrishna S VOCB", "latitude": -32.14, "longitude": 33.48201, "altitude": 39982, "groundspeed": 445, "heading": 319, "transponder": "1042", "aircraft": "A388", "departure": "YSSY", "arrival": "FAOR", "plannedAltitude": "34000" }
```

Controller records swap the flight fields for `frequency`, `facility`, `rating`, and `visualRange`.

### ✨ Why choose this Actor

- Reads the official VATSIM Data v3 source, so the data matches what the network publishes.
- One flat record per pilot or controller, ready for tables and maps.
- Flight plans are flattened, no nested digging required.
- No API key, account, or login needed.
- Works for the whole network or a single airport with one filter.

### 📈 How it compares to alternatives

| Approach | Setup | Flat records | Filters | Controllers too |
|---|---|---|---|---|
| This Actor | None | Yes | Callsign, departure, arrival | Yes |
| Raw VATSIM JSON feed | Manual parsing | No, deeply nested | None | Manual |
| Third party map sites | Account often needed | No structured output | Limited | Varies |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the VATSIM Live Network Scraper.
3. Pick a `mode`, `pilots` or `controllers`.
4. Optionally add a callsign, departure, or arrival filter and set `maxItems`.
5. Click Start and collect the results from the output table.

### 💼 Business use cases

#### Event operations

| Need | How this helps |
|---|---|
| Monitor traffic load during a fly-in | Count pilots inbound to the event airport |
| Track ATC coverage | List online controllers and their facilities |

#### Community dashboards

| Need | How this helps |
|---|---|
| Live network map | Plot latitude and longitude per pilot |
| Activity stats | Aggregate connected members over time |

#### Training and review

| Need | How this helps |
|---|---|
| Study filed routes | Read the route and aircraft fields |
| ATC staffing review | See rating and facility per controller |

#### Analytics

| Need | How this helps |
|---|---|
| Popular city pairs | Group flights by departure and arrival |
| Fleet mix | Count aircraft types across the network |

### 🔌 Automating VATSIM Live Network Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub, or Google Drive through Apify integrations and webhooks. Trigger on a schedule, then forward each snapshot to your spreadsheet, database, or chat channel automatically.

### 🌟 Beyond business use cases

- **Research:** study network behavior and traffic patterns across regions.
- **Personal:** track a friend's flight or your favorite airline callsigns.
- **Non-profit:** support volunteer ATC training groups with live staffing views.
- **Experimentation:** feed live positions into your own mapping or alerting projects.

### 🤖 Ask an AI assistant

Paste a results sample into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to summarize busiest routes, group flights by region, or rank online facilities.

### ❓ Frequently Asked Questions

**Is a VATSIM account required?** No. The data feed is public and keyless.

**How fresh is the data?** It is a live snapshot taken when the run starts.

**How many records can I get?** Typically around 1,800 pilots and 190 controllers when the network is busy. Free plan runs are capped at 10.

**Can I get a single airport's traffic?** Yes, use the departure or arrival filter for pilots.

**Does it include controllers?** Yes, set `mode` to `controllers`.

**What is the CID?** It is the unique VATSIM member identifier.

**Why are some flight plan fields empty?** That pilot has not filed a flight plan yet.

**Can I filter by airline?** Yes, use the callsign filter with the airline prefix like `BAW` or `DLH`.

**Does it cover the whole world?** Yes, the network is global and so is the feed.

**Is historical data available?** No, the feed is current state only. Schedule repeated runs to build your own history.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and prebuilt integrations to push each snapshot into the tools your team already uses.

### 🔗 Recommended Actors

- [ADSB.lol Live Flights Scraper](https://apify.com/parseforge) for real aircraft tracking.
- [AviationWeather METAR TAF Scraper](https://apify.com/parseforge) for live aviation weather.
- [OpenChargeMap Scraper](https://apify.com/parseforge) for points of interest data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with VATSIM. Only publicly available data is collected.

# Actor input Schema

## `mode` (type: `string`):

What to scrape from the live VATSIM network. 'pilots' returns connected pilots with position and flight plan. 'controllers' returns online air traffic controllers with frequency and facility.

## `callsign` (type: `string`):

Optional. Keep only records whose callsign contains this text (case insensitive). Example DLH or BAW.

## `departure` (type: `string`):

Optional. Keep only pilots whose flight plan departure airport matches this ICAO code. Example EGLL.

## `arrival` (type: `string`):

Optional. Keep only pilots whose flight plan arrival airport matches this ICAO code. Example KJFK.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "mode": "pilots",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/vatsim-live-network-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/vatsim-live-network-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/vatsim-live-network-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/vatsim-live-network-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VATSIM Live Network Scraper",
        "description": "Pull the live VATSIM flight simulation network in one pass. Online pilots arrive with callsign, position, altitude, ground speed, heading, transponder, and filed route, plus controllers with frequency and facility. Filter by airport or callsign for live maps and event tracking.",
        "version": "0.1",
        "x-build-id": "c2WxZufnQApuHt6HP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~vatsim-live-network-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-vatsim-live-network-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~vatsim-live-network-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-vatsim-live-network-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~vatsim-live-network-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-vatsim-live-network-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "pilots",
                            "controllers"
                        ],
                        "type": "string",
                        "description": "What to scrape from the live VATSIM network. 'pilots' returns connected pilots with position and flight plan. 'controllers' returns online air traffic controllers with frequency and facility.",
                        "default": "pilots"
                    },
                    "callsign": {
                        "title": "Callsign Filter",
                        "type": "string",
                        "description": "Optional. Keep only records whose callsign contains this text (case insensitive). Example DLH or BAW."
                    },
                    "departure": {
                        "title": "Departure Airport (pilots only)",
                        "type": "string",
                        "description": "Optional. Keep only pilots whose flight plan departure airport matches this ICAO code. Example EGLL."
                    },
                    "arrival": {
                        "title": "Arrival Airport (pilots only)",
                        "type": "string",
                        "description": "Optional. Keep only pilots whose flight plan arrival airport matches this ICAO code. Example KJFK."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```