# ESPN Formula 1 Scraper (`parseforge/espn-f1-results-scraper`) Actor

Scrapes Formula 1 scoreboard results, team information, and news articles from ESPN. Returns each record as a flat row in your dataset.

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

## Pricing

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

### ESPN Formula 1 Scraper

**Scrape Formula 1 results, team data, and news from ESPN, up to a million items per run.** Every record comes with structured race data, team details, or article information. No login or API key. Export to CSV, JSON, Excel, or XML.

ESPN's public F1 pages are built for browsers, not for bulk analysis. This Actor reads the scoreboard, teams, and news feeds directly, filters by date, and returns each match in one fixed schema. You get clean, structured data without writing a single parser.

| Who uses it | What they scrape ESPN for |
|---|---|
| F1 data analysts | Building historical race result databases for performance modeling. |
| Sports journalists | Monitoring breaking F1 news and team announcements for story leads. |
| Fantasy league developers | Pulling driver and constructor standings to power fantasy platforms. |
| Betting modelers | Collecting race outcomes and team stats to feed predictive algorithms. |

### What it does

This Actor collects Formula 1 scoreboard results, team information, or news articles from ESPN and returns each one as a flat row.

- 🏎️ **Scoreboard endpoint:** fetches race results, driver standings, and constructor points for a given date.
- 👥 **Teams endpoint:** retrieves current team rosters, car details, and season statistics.
- 📰 **News endpoint:** pulls the latest F1 headlines, article summaries, and publication dates.
- 📅 **Date filter:** target a specific race weekend by providing a YYYYMMDD date, or leave empty for today's data.
- 🔢 **Max items control:** set a hard limit from 1 to 1,000,000 results to cap your dataset size.

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

### What you can do with ESPN data

**📊 Archive race results.**

A data engineer runs the scoreboard endpoint daily to build a complete, queryable history of F1 race outcomes and driver standings.

**📝 Track team changes.**

A motorsport blogger scrapes the teams endpoint weekly to catch driver swaps, car updates, and constructor stats for season preview articles.

**📰 Monitor F1 news.**

A content aggregator pulls the news endpoint every hour to surface breaking stories and ESPN exclusives on their platform.

**📈 Feed a prediction model.**

A betting analyst collects dated race results to train a machine learning model on track-specific driver performance.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | Access public ESPN F1 feeds without registration or OAuth. |
| **Structured output** | Every race, team, or news item lands as a clean, flat row ready for analysis. |
| **Date-targeted** | Pull results from a specific race day instead of scraping the entire season. |
| **Flexible endpoints** | One Actor covers scoreboards, teams, and news, no need for separate scrapers. |

### How it compares

This Actor focuses exclusively on ESPN's Formula 1 data, while the competitors below cover multiple sports. Here is how they compare on F1-specific capabilities.

| Feature | ParseForge | ESPN MCP Server | ESPN Sports Scraper | ESPN Scraper - Scores, Fixtures & Teams |
|---|---|---|---|---|
| F1-specific endpoint selection | Yes (scoreboard, teams, news) | Not listed | Not listed | Not listed |
| Date filter for historical F1 races | Yes (YYYYMMDD) | Not listed | Not listed | Not listed |
| F1 news scraping | Yes | Yes | Yes | Not listed |
| F1 team rosters and stats | Yes | Yes | Yes | Yes |
| No API key or OAuth required | Yes | Not listed | Yes | Yes |
| Up to 1,000,000 results per run | Yes | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor by selecting an endpoint and optionally a date, and the max items limit caps how many records reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "endpoint": "scoreboard",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "endpoint": "scoreboard",
 "maxItems": 200
}
```

### Pricing

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

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.85 |
| 1,000 results | $8.50 |
| 10,000 results | $85.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 [ESPN Formula 1 Scraper](https://apify.com/parseforge/espn-f1-results-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 ESPN 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/espn-f1-results-scraper"
```

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

### Troubleshooting

**Why am I getting no results?**

Ensure the date filter, if used, is a valid YYYYMMDD date with an actual race. On non-race days, the scoreboard may be empty. Try removing the date filter to fetch today's data, or switch to the news or teams endpoint.

**Why does the run stop after only 10 items?**

Free Apify users are limited to a 10-item preview. Upgrade to a paid plan to increase the max items limit up to 1,000,000.

**The data looks different from what I see on the ESPN website.**

ESPN occasionally updates its page layout. If the output schema changes unexpectedly, check the Actor's run log for parsing warnings and consider updating to the latest Actor version.

**I get an error when using a date filter.**

The date must be exactly 8 digits in YYYYMMDD format, e.g., 20240302 for March 2, 2024. Do not include hyphens or slashes.

**The run takes a long time or times out.**

Lower the max items limit. Requesting a very large number of items can increase run time. If you need millions of records, split the job across multiple runs with different date ranges.

### FAQ

| Question | Answer |
|---|---|
| What F1 data can I scrape with this Actor? | You can scrape race results and standings from the scoreboard, team rosters and stats from the teams endpoint, and headlines and summaries from the news feed. The endpoint selector lets you choose which dataset to target. |
| Can I get historical F1 results, not today's? | Yes. Use the optional date filter in YYYYMMDD format to target a specific race day. Leave it empty to fetch the current day's data. |
| How many results can I pull in one run? | Free users are limited to a 10-item preview. Paid Apify users can set the max items limit up to 1,000,000 per run. |
| Does this scraper require an ESPN API key? | No. It reads the public ESPN web pages directly, so no registration, API key, or OAuth flow is needed. |
| What format does the output come in? | The Actor returns data in a standard Apify dataset. You can export it to CSV, JSON, Excel, or XML from the Apify console or via API. |
| Can I scrape F1 data for a whole season at once? | The Actor fetches data for one date per run. To collect a full season, run it multiple times with different date values, or schedule it to run after each race weekend. |
| Does it scrape live, in-progress race data? | It captures whatever ESPN displays on the public page at the moment of the request. For live updating data, you can schedule the Actor to run at short intervals during a race. |
| Is this limited to Formula 1, or can I scrape other sports? | This Actor is built specifically for ESPN's Formula 1 section. For other sports, consider a general ESPN scraper from the Apify Store. |
| What do I do if I get an empty dataset? | Check that your date filter matches a real race day. If you leave the date empty, it fetches today's data, which may be empty on non-race days. Also verify the endpoint selection. |
| Can I filter news articles by keyword or author? | The Actor does not have keyword or author filters. It pulls the latest headlines from the ESPN F1 news feed, and you can filter the resulting dataset after the run. |

### 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 ESPN, Inc. 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

## `endpoint` (type: `string`):

ESPN sub-endpoint to fetch.

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

Free users limited to 10 F1 results (preview). Paid users optional, up to 1,000,000.

## `dates` (type: `string`):

Optional YYYYMMDD date for scoreboard. Leave empty for today.

## Actor input object example

```json
{
  "endpoint": "scoreboard",
  "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 = {
    "endpoint": "scoreboard",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/espn-f1-results-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 = {
    "endpoint": "scoreboard",
    "maxItems": 10,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/espn-f1-results-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/tu8A6ZsOTXpcnGUaU/builds/Zo8p2k4EuiS2aJPfg/openapi.json