# Transport for London (TfL) Live Status Scraper (`parseforge/tfl-london-status-scraper`) Actor

Scrape live Transport for London status: Tube, DLR, Overground, Elizabeth line, Bus, and Cycle line statuses; current disruptions; and station catalogues. Filter by transit mode.

- **URL**: https://apify.com/parseforge/tfl-london-status-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $29.25 / 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)

## 🚦 TfL London Live Status Scraper

> 🚀 **Export Transport for London's live status feed in seconds.** Per-line service health for the Tube, Overground, Elizabeth line, DLR, buses, trams, river bus, cable car, and Santander Cycles, plus current disruptions and the full station catalogue. No sign-up, no manual scraping.

> 🕒 **Last updated:** 2026-05-15 · **📊 Up to 42 fields** per record · **🚇 10 transport modes** · **🌐 All London zones** · **🟢 Live status feed**

The **TfL London Live Status Scraper** exports the official **Transport for London** live status feed and returns up to **42 fields per record**, depending on whether you fetch line statuses, disruptions, or station catalogues. The TfL feed is the canonical reference for London transit and powers Citymapper, the official TfL Go app, and dozens of accessibility and journalism projects.

The catalogue covers **10 transport modes** across every London travel zone: London Underground (Tube), DLR, London Overground, Elizabeth line, National Rail services managed by TfL, the bus network, trams, river bus, the IFS Cloud cable car, and Santander Cycles. This Actor makes the live feed downloadable as CSV, Excel, JSON, or XML in under a minute. Filtering by transport mode runs server-side.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| London transit-app developers, accessibility advocates, urban-planning teams, real-estate platforms, journalism teams, mobility researchers | Live service-status widgets, disruption alerts, station-accessibility audits, commuter dashboards, real-estate transit scoring, transport-equity research |

---

### 📋 What the TfL London Live Status Scraper does

Three data modes, each across 10 transport modes:

- 🚇 **Line status.** Service health per line, with severity codes (1-20), human-readable descriptions, and active disruptions.
- ⚠️ **Disruptions.** Current incidents with category, description, affected routes, affected stops, and last-update time.
- 🚉 **Stations.** Full catalogue with NaPTAN IDs, lat/lon, accessibility info (lifts, boarding ramps, toilets, cash machines), and modes served.

Filter every mode by transport mode (Tube, DLR, Overground, Elizabeth line, National Rail, bus, tram, river bus, cable car, cycle).

> 💡 **Why it matters:** TfL serves more than 4 million weekday journeys. Live status data powers commuter apps, accessibility scoring, and journalism on service equity. Building your own pipeline means juggling multiple TfL data products and reconciling status codes. This Actor skips all of that.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing live Tube line status pushed to Slack._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>mode</td><td>string</td><td>"line-status"</td><td>One of line-status, disruptions, stations.</td></tr>
<tr><td>transportMode</td><td>string</td><td>"tube"</td><td>Restrict to one of 10 TfL transport modes.</td></tr>
</tbody>
</table>

**Example: live Tube line status.**

```json
{
    "maxItems": 20,
    "mode": "line-status",
    "transportMode": "tube"
}
````

**Example: current Elizabeth line disruptions.**

```json
{
    "maxItems": 50,
    "mode": "disruptions",
    "transportMode": "elizabeth-line"
}
```

> ⚠️ **Good to Know:** TfL severity codes range from 1 (closed) to 20 (good service). The 14 standard codes map roughly to "Closed", "Suspended", "Part Suspended", "Planned Closure", "Part Closure", "Severe Delays", "Reduced Service", "Bus Service", "Minor Delays", "Good Service", and a few rarely used codes. The Actor surfaces the raw severity number plus the official description.

***

### 📊 Output

Each record contains up to **42 fields** depending on the mode you choose. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema (representative subset by mode)

| Field | Type | Where it appears | Example |
|---|---|---|---|
| 🆔 `id` | string | all | `"victoria"`, `"940GZZLUVIC"`, `"alert-12345"` |
| 📌 `name` | string | all | `"Victoria"` |
| 🚇 `modeName` | string | line-status, stations | `"tube"` |
| 🔗 `url` | string | null | line-status, disruptions | `"https://tfl.gov.uk/tube/status"` |
| 🔴 `statusSeverity` | number | line-status | `10` |
| 🚦 `statusSeverityDescription` | string | line-status | `"Good Service"` |
| 🚦 `hasActiveDisruption` | boolean | line-status | `false` |
| 📝 `reason` | string | null | line-status, disruptions | `"Severe delays due to a signal failure at Oxford Circus"` |
| 🏷️ `disruptionCategory` | string | null | disruptions | `"RealTime"` |
| 📝 `disruptionDescription` | string | disruptions | `"Severe delays..."` |
| 📦 `lineStatuses` | array | line-status | nested status entries |
| 📦 `affectedRoutes` | array | disruptions | route IDs and names |
| 📦 `affectedStops` | array | disruptions | stop IDs and names |
| 🆔 `naptanId` | string | stations | `"940GZZLUVIC"` |
| 📍 `latitude` | number | stations | `51.4961` |
| 📍 `longitude` | number | stations | `-0.144` |
| 🚇 `modes` | array | stations | `["tube", "national-rail"]` |
| ♿ `lifts` | string | null | stations | `"Step-free interchange"` |
| 🚻 `toilets` | string | null | stations | `"Available with disabled access"` |
| 💵 `cashMachines` | string | null | stations | `"In ticket hall"` |
| ♿ `boardingRamps` | string | null | stations | `"Manual boarding ramp"` |
| 📦 `lineGroups` | array | stations | grouped lines per platform |
| 🕒 `snapshotTime` | ISO 8601 | all | `"2026-05-15T18:32:11.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🚇 Line status: Victoria line (Good Service)</strong></summary>

```json
{
    "id": "victoria",
    "name": "Victoria",
    "modeName": "tube",
    "url": "https://tfl.gov.uk/tube/status",
    "statusSeverity": 10,
    "statusSeverityDescription": "Good Service",
    "hasActiveDisruption": false,
    "reason": null,
    "lineStatuses": [
        { "statusSeverity": 10, "statusSeverityDescription": "Good Service", "reason": null }
    ],
    "serviceTypes": [{ "name": "Regular", "uri": "/Line/Route?ids=Victoria&serviceTypes=Regular" }],
    "created": "2026-05-15T05:00:00Z",
    "modified": "2026-05-15T18:30:00Z",
    "snapshotTime": "2026-05-15T18:32:11.000Z"
}
```

</details>

<details>
<summary><strong>⚠️ Disruption: Elizabeth line signal failure</strong></summary>

```json
{
    "id": "elizabeth-disruption-12345",
    "category": "RealTime",
    "categoryDescription": "RealTime",
    "type": "lineInfo",
    "description": "Elizabeth line: Severe delays between Paddington and Liverpool Street due to a signal failure at Bond Street.",
    "summary": "Severe delays Paddington to Liverpool Street",
    "additionalInfo": "Tickets accepted on London Underground services.",
    "affectedRoutes": [{ "id": "elizabeth", "name": "Elizabeth line" }],
    "affectedStops": [
        { "id": "910GBONDST", "name": "Bond Street" },
        { "id": "910GLIVST", "name": "Liverpool Street" }
    ],
    "lastUpdate": "2026-05-15T18:25:42Z",
    "snapshotTime": "2026-05-15T18:32:11.000Z"
}
```

</details>

<details>
<summary><strong>🚉 Station record: Victoria (Tube + National Rail)</strong></summary>

```json
{
    "id": "940GZZLUVIC",
    "name": "Victoria Underground Station",
    "naptanId": "940GZZLUVIC",
    "stationNaptan": "940GZZLUVIC",
    "icsCode": "1000248",
    "modes": ["tube", "national-rail"],
    "placeType": "StopPoint",
    "stopType": "NaptanMetroStation",
    "latitude": 51.4961,
    "longitude": -0.144,
    "status": true,
    "lifts": "Step-free interchange",
    "toilets": "Available with disabled access",
    "cashMachines": "In ticket hall",
    "helpPoints": "Yes",
    "boardingRamps": "Manual boarding ramp",
    "hubNaptanCode": "HUBVIC",
    "childStopCount": 8,
    "lineGroups": [
        { "naptanIdReference": "940GZZLUVIC", "stationAtcoCode": "940GZZLUVIC", "lineIdentifier": ["victoria", "circle", "district"] }
    ],
    "address": "Victoria, London, SW1V 1JT",
    "snapshotTime": "2026-05-15T18:32:11.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚇 | **Ten transport modes.** Tube, Overground, Elizabeth line, DLR, National Rail, bus, tram, river bus, cable car, cycle. |
| 📡 | **Live every run.** Status, disruptions, and station data reflect the latest TfL snapshot. |
| 🎯 | **Three data modes.** Line status, disruptions, stations, all from one Actor. |
| ♿ | **Accessibility ready.** Lifts, boarding ramps, toilets, and step-free flags on every station. |
| 🔍 | **Server-side filters.** Restrict by transport mode in one click. |
| ⚡ | **Fast.** Status for every Tube line in under five seconds. |
| 🚫 | **No sign-up.** Works against the public TfL live status feed. |

> 📊 The TfL feed is the data layer behind every commuter app, accessibility audit, and London transit-equity investigation.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ TfL London Live Status Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All TfL modes** | **Live per run** | mode, transport mode | ⚡ 2 min |
| Manual TfL Tube status page | Free | Tube only | Live | None | 🚫 Not bulk-friendly |
| Scrape + parse + maintain | Free time | Variable | Manual | None | 🐢 Hours |
| Commercial transit APIs | $99+/month | Multi-city | Live | Many | ⏳ Integration |

Pick this Actor when you want filtered, structured TfL data without writing scrapers or paying for a multi-city aggregator.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the TfL London Live Status Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a data mode (line status, disruptions, stations) and a transport mode.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the live feed.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded TfL feed: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🚇 Commuter Apps & Workplace Tools

- Build a live Tube status board for an office lobby
- Push severe-delay alerts to a workplace Slack channel
- Power a "leave by" widget that watches your line
- Surface accessible-station info to disabled commuters

</td>
<td width="50%" valign="top">

#### 🏠 Real Estate & PropTech

- Score listings by walking time to a Tube station
- Filter rentals near step-free stations
- Add live transport-mode info to listing pages
- Inform commercial-site selection with TfL coverage

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Journalism & Civic Tech

- Track Tube reliability by line over time
- Quantify Elizabeth line disruption frequency
- Audit step-free coverage across boroughs
- Investigate signal-failure clusters

</td>
<td width="50%" valign="top">

#### 🏙️ Urban Planning & Mobility Research

- Compare service equity across London zones
- Map step-free station coverage to demographics
- Build commute-time isochrones from TfL geography
- Power transit-accessibility scores for housing analysis

</td>
</tr>
</table>

***

### 🔌 Automating TfL London Live Status Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor every minute (status), every five minutes (disruptions), or daily (station catalogue refresh).

***

### 🌟 Beyond business use cases

Live transit data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Mobility studies on TfL service equity
- Replicate published Tube-reliability papers
- Teach geospatial analysis with real London transit feeds
- Train ML models on disruption frequency

</td>
<td width="50%">

#### 🎨 Personal and creative

- Build a personal commute dashboard for the Northern line
- Visualize a year of Tube delays as data art
- Power a Slack bot that warns you before you leave
- Curate a hobbyist station-photo archive

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Score TfL accessibility for disability-rights advocacy
- Audit step-free coverage borough by borough
- Provide free transit data to community newsrooms
- Support civic dashboards on disruption frequency

</td>
<td width="50%">

#### 🧪 Experimentation

- Train a delay-prediction model on hourly snapshots
- Validate transit-app UX with real-time data
- Prototype a step-free routing assistant
- Test smart-city dashboards with live TfL feeds

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20TfL%20London%20Live%20Status%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20TfL%20London%20Live%20Status%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20TfL%20London%20Live%20Status%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20TfL%20London%20Live%20Status%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick one of three data modes, choose a transport mode, and run. The Actor pulls the official TfL live status feed and writes one clean record per line, disruption, or station.

#### 📏 How accurate is the data?

Data mirrors the official TfL feed exactly. Line statuses update within minutes of operational changes. Disruptions reflect TfL's own controllers in real time.

#### 🔁 How fresh are the line statuses and disruptions?

Live. Each Actor run snapshots the current state, so back-to-back runs return updated severity codes and disruption descriptions.

#### 🚇 Which transport modes are covered?

All ten TfL modes: Tube (London Underground), DLR, London Overground, Elizabeth line, TfL-managed National Rail services, bus, tram, river bus, IFS Cloud cable car, and Santander Cycles.

#### 🔢 What do the severity codes mean?

The standard scale runs from 1 (Closed) to 20 (Good Service), covering closures, severe delays, reduced service, minor delays, and good service. Each record includes a human-readable description alongside the code.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to refresh status every minute, disruptions every five minutes, or station catalogue daily.

#### ⚖️ Is this data legal to use?

Yes. TfL publishes its live status feed under permissive open-data terms. Attribution to TfL is required.

#### 💼 Can I use this data commercially?

Yes. TfL welcomes commercial use of its open data for transit apps, journalism, and analytics. Verify the latest terms in TfL's data policy.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling.

#### ♿ Are accessibility flags included?

Yes. Station records include lifts, boarding ramps, toilets, and step-free interchange information when TfL publishes them.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

TfL London Live Status Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Push delays and disruptions to channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe transit data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push disruption alerts into a workplace stack, or stream daily station snapshots into a dashboard.

***

### 🔗 Recommended Actors

- [**🚇 MBTA Live Transit Scraper**](https://apify.com/parseforge/mbta-transit-scraper) - Boston transit routes, stops, vehicles, and predictions
- [**🗺️ OSRM Routing Scraper**](https://apify.com/parseforge/osrm-routing-scraper) - Driving, cycling, and walking routes anywhere
- [**🌍 Carbon Intensity UK Scraper**](https://apify.com/parseforge/carbon-intensity-uk-scraper) - UK grid carbon intensity in gCO2/kWh
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**📰 Guardian Article Search Scraper**](https://apify.com/parseforge/guardian-content-search-scraper) - Search The Guardian's full article archive

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more transit and UK-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Transport for London or any of its affiliates. All trademarks mentioned are the property of their respective owners. Only publicly available open transit data is collected.

# Actor input Schema

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

Choose what to scrape. Line-status returns service health per line. Disruptions returns active incidents. Stations returns the full station catalogue with NaPTAN. Arrivals returns next vehicles for a specific line (set lineId). Bike-points returns Santander Cycles dock occupancy. Air-quality returns the daily London air-quality forecast. Occupancy returns live car-park occupancy.

## `transportMode` (type: `string`):

Limit results to one TfL transport mode, or use 'All modes' to fan out across every mode (Tube, DLR, Overground, Elizabeth line, National Rail, Bus, Tram, River Bus, Cable Car, Cycle).

## `lineId` (type: `string`):

Required when mode is 'Arrivals'. Single line identifier (e.g. 'central', 'piccadilly', 'jubilee', 'elizabeth').

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

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

## Actor input object example

```json
{
  "mode": "line-status",
  "transportMode": "all",
  "lineId": "",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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/tfl-london-status-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/tfl-london-status-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/tfl-london-status-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Transport for London (TfL) Live Status Scraper",
        "description": "Scrape live Transport for London status: Tube, DLR, Overground, Elizabeth line, Bus, and Cycle line statuses; current disruptions; and station catalogues. Filter by transit mode.",
        "version": "0.0",
        "x-build-id": "BgUFmrEYoYaS1pTqN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~tfl-london-status-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-tfl-london-status-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~tfl-london-status-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-tfl-london-status-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~tfl-london-status-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-tfl-london-status-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",
                "properties": {
                    "mode": {
                        "title": "Data Mode",
                        "enum": [
                            "line-status",
                            "disruptions",
                            "stations",
                            "arrivals",
                            "bike-points",
                            "air-quality",
                            "occupancy"
                        ],
                        "type": "string",
                        "description": "Choose what to scrape. Line-status returns service health per line. Disruptions returns active incidents. Stations returns the full station catalogue with NaPTAN. Arrivals returns next vehicles for a specific line (set lineId). Bike-points returns Santander Cycles dock occupancy. Air-quality returns the daily London air-quality forecast. Occupancy returns live car-park occupancy.",
                        "default": "line-status"
                    },
                    "transportMode": {
                        "title": "Transport Mode",
                        "enum": [
                            "all",
                            "tube",
                            "dlr",
                            "overground",
                            "elizabeth-line",
                            "national-rail",
                            "bus",
                            "tram",
                            "river-bus",
                            "cable-car",
                            "cycle"
                        ],
                        "type": "string",
                        "description": "Limit results to one TfL transport mode, or use 'All modes' to fan out across every mode (Tube, DLR, Overground, Elizabeth line, National Rail, Bus, Tram, River Bus, Cable Car, Cycle).",
                        "default": "all"
                    },
                    "lineId": {
                        "title": "Line ID (Arrivals mode only)",
                        "type": "string",
                        "description": "Required when mode is 'Arrivals'. Single line identifier (e.g. 'central', 'piccadilly', 'jubilee', 'elizabeth').",
                        "default": ""
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
