# MBTA Boston Live Transit Scraper (`parseforge/mbta-transit-scraper`) Actor

Scrapes MBTA transit data including routes, stops, vehicles, predictions, alerts, schedules, and shapes. Returns each record as a flat row with all attributes.

- **URL**: https://apify.com/parseforge/mbta-transit-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $28.87 / 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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### MBTA Boston Live Transit Scraper

**Scrape live MBTA Boston transit data for routes, stops, vehicles, predictions, alerts, and more.** Every record comes with its full set of attributes, ready for export to CSV, JSON, Excel, or XML. No API key required.

The MBTA's official API requires an API key and has rate limits. This Actor reads the public MBTA v3 API directly, returning live and scheduled transit data for the Boston area. Filter by route, stop, transit mode, or direction, and get each record in a flat, consistent schema.

| Who uses it | What they scrape MBTA for |
|---|---|
| Transit app developers | Build real-time arrival displays and trip planners |
| Urban planners | Analyze service patterns and stop usage |
| Data journalists | Report on MBTA performance and disruptions |
| Researchers | Study public transit behavior and accessibility |
| Commuters | Check live arrivals and service alerts |

### What it does

This Actor collects MBTA transit data by mode, including routes, stops, vehicles, predictions, alerts, trips, schedules, shapes, facilities, and lines, and returns each record as a flat row.

- 🚇 **Routes and lines:** Get all MBTA routes with their modes, names, and line groupings.
- 🚏 **Stops and facilities:** Retrieve station details, including accessibility features like elevators and escalators.
- 🚌 **Live vehicles:** Track current vehicle positions across the network.
- ⏱️ **Predictions:** Get next arrival and departure times for any stop or route.
- ⚠️ **Alerts:** Monitor service disruptions and advisories in real time.
- 🗓️ **Schedules and trips:** Access timetables and scheduled trips for planning.
- 🗺️ **Shapes:** Download route geometry polylines for mapping.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with MBTA data

**📱 Build a real-time arrival board.**

A developer runs the Actor with mode=predictions and a stop filter to power a station display showing next train and bus arrivals.

**🚨 Monitor service disruptions.**

A transit advocate runs the Actor with mode=alerts and a route filter to track and report on MBTA service issues.

**🗺️ Map the MBTA network.**

A GIS analyst runs the Actor with mode=shapes to download route geometry for a custom transit map.

**📊 Analyze stop usage.**

An urban planner runs the Actor with mode=stops and a transit mode filter to study station accessibility and ridership patterns.

**⏰ Plan a commute.**

A commuter runs the Actor with mode=schedules and a stop filter to get the day's timetable for their station.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Uses the public MBTA v3 API without registration |
| **Live and scheduled** | Covers real-time predictions, vehicles, and static schedules |
| **Flexible filters** | Narrow by route, stop, mode, or direction |
| **Flat output** | Each record is a simple row, ready for analysis |
| **Multiple formats** | Export to CSV, JSON, Excel, or XML |

### How it compares

This Actor covers all MBTA data modes, while the competitor focuses only on live arrivals and departures.

| Feature | ParseForge | MBTA Live Arrivals Scraper - Boston Transit Data |
|---|---|---|
| Live arrival predictions | Yes | Yes |
| Live vehicle positions | Yes | Not listed |
| Service alerts | Yes | Not listed |
| Schedules and timetables | Yes | Not listed |
| Route geometry (shapes) | Yes | Not listed |
| Stop and facility details | Yes | Not listed |

### Configure the run

Drive the Actor with a data mode and optional filters for route, stop, transit mode, and direction. Filters run as each record is read, so only matching data reaches your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0385 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $3.85 |
| 1,000 results | $38.50 |
| 10,000 results | $385.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [MBTA Boston Live Transit Scraper](https://apify.com/parseforge/mbta-transit-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to MBTA through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/mbta-transit-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. For predictions and schedules, you must provide a routeFilter or stopFilter. For trips and shapes, a routeFilter is required. Also ensure your route or stop IDs are correct.

**Why are times in a different timezone?**

All times are in America/New\_York. If you need UTC, you can convert after export.

**How do I get more than 10 records?**

Increase the maxItems input. The default is 10, but you can set it up to 1,000,000.

**Why is my sort not working?**

Make sure you use a valid field name and prefix with '-' for descending order. For example, '-arrival\_time' sorts by arrival time descending.

**Can I get data for a specific direction?**

Yes, use the directionId input. 0 is typically outbound, 1 is inbound, or choose 'any'.

### FAQ

| Question | Answer |
|---|---|
| Do I need an MBTA API key? | No. This Actor uses the public MBTA v3 API, which does not require an API key for basic access. |
| What data modes are available? | You can scrape routes, stops, vehicles, predictions, alerts, trips, schedules, shapes, facilities, and lines. |
| How do I filter results? | Use the routeFilter, stopFilter, transitMode, and directionId inputs to narrow results. Filters are applied as data is fetched. |
| Can I get live vehicle positions? | Yes, set mode to 'vehicles' to get current positions of buses, trains, and ferries. |
| What timezone are the times in? | All times are returned in the local Boston timezone (America/New\_York). |
| How many records can I get? | You can set maxItems up to 1,000,000 records per run. |
| Can I include related resources? | Yes, use the 'include' input to side-load related resources like route, stop, trip, or vehicle details. |
| What export formats are supported? | You can export data to CSV, JSON, Excel, or XML. |
| Is this Actor free to use? | The Actor runs on the Apify platform, and usage is subject to Apify's pricing. The MBTA API itself is free. |
| Can I schedule this Actor to run periodically? | Yes, you can set up a schedule in Apify to run the Actor at regular intervals, such as every minute for live data. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Massachusetts Bay Transportation Authority. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Choose what to scrape. Predictions and Schedules require routeFilter or stopFilter. Trips and Shapes require routeFilter. Times are returned in the local Boston (America/New\_York) timezone.

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

How many transit records to collect per run.

## `sectionCaptionFilters` (type: `string`):

Narrow results by route, stop, or transit mode.

## `routeFilter` (type: `string`):

Comma-separated route IDs (e.g. 'Red,Orange,Green-B,1,77'). Used by predictions, vehicles, alerts, and stops.

## `stopFilter` (type: `string`):

Comma-separated stop IDs (e.g. 'place-pktrm,70061'). Used by predictions and alerts.

## `transitMode` (type: `string`):

Filter by transit mode (route\_type). Heavy rail = subway, light rail = trolley, bus = local bus, ferry = harbor ferry, commuter-rail = MBTA Commuter Rail.

## `directionId` (type: `string`):

Direction of travel: 0 (typically Outbound / South / West), 1 (Inbound / North / East), or any.

## `sort` (type: `string`):

Sort field. Prefix with '-' for descending (e.g. 'arrival\_time', '-departure\_time', 'name', '-severity'). Leave blank for default ordering.

## `include` (type: `string`):

Comma-separated list of related resources to side-load (e.g. 'route,stop,trip,vehicle'). Useful for predictions and schedules.

## Actor input object example

```json
{
  "mode": "routes",
  "maxItems": 10,
  "routeFilter": "",
  "stopFilter": "",
  "transitMode": "all",
  "directionId": "any",
  "sort": "",
  "include": ""
}
```

# 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,
    "routeFilter": "",
    "stopFilter": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/mbta-transit-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,
    "routeFilter": "",
    "stopFilter": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/mbta-transit-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 '{
  "maxItems": 10,
  "routeFilter": "",
  "stopFilter": ""
}' |
apify call parseforge/mbta-transit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/mbta-transit-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/vpD3rVEajyWBvbUFZ/builds/XvVnZhhmZ63pg7iuh/openapi.json