# NASCAR Racing Reference Season Stats Scraper (`parseforge/nascar-racing-reference-scraper`) Actor

Scrapes NASCAR season race results from Racing Reference. Returns finish, start, laps, status, and points for each driver in a given series and year.

- **URL**: https://apify.com/parseforge/nascar-racing-reference-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, News
- **Stats:** 3 total users, 1 monthly users, 92.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### NASCAR Racing Reference Season Stats Scraper

**Scrape NASCAR season race results from Racing Reference for any series and year, up to a million per run.** Every result includes finish, start, laps, status, and points. No login or API key. Export to CSV, JSON, Excel, or XML.

NASCAR's official stats are scattered across PDFs and live timing feeds. Racing Reference is the definitive archive for every Cup, Xfinity, Truck, and ARCA race, but there is no bulk export. This Actor reads the season schedule and race results pages directly, filters by series and year, and returns each race result in one fixed schema.

| Who uses it | What they scrape Racing Reference for |
|---|---|
| DFS players | Build a historical performance database for lineup optimization. |
| Betting modelers | Feed finish, start, and lap data into predictive models. |
| Journalists | Pull a season's results to fact-check a story or build a data graphic. |
| NASCAR historians | Archive complete season results for long-term trend analysis. |

### What it does

This Actor collects NASCAR race results from Racing Reference for a given season and series, and returns each driver's finish as a flat row.

- 🏁 **Season results:** scrape every race in a season for a single series.
- 📅 **Year filter:** target any season from the archive by four-digit year.
- 🏎️ **Series selector:** choose Cup, Xfinity, Truck, or ARCA.
- 📊 **Flat rows:** each driver's finish, start, laps, status, and points in one row.

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

### What you can do with Racing Reference data

**💰 Build a DFS model.**

A daily fantasy player scrapes a full Cup Series season to train a model on finish position versus starting position and laps led.

**📈 Feed a betting algorithm.**

A sports bettor pulls five years of Truck Series results to calculate driver performance trends at specific track types.

**📝 Research a season recap.**

A motorsport journalist scrapes the 2024 Xfinity season to verify top-10 streaks and DNF causes for a year-end article.

**🗄️ Archive historical data.**

A NASCAR historian scrapes every ARCA season from 2000 onward to build a personal searchable database.

### Why choose this scraper

|  | What you get |
|---|---|
| **Finish position** | Where each driver ended the race |
| **Start position** | Where each driver began the race |
| **Laps completed** | How many laps each driver ran |
| **Status** | Running, crash, engine, or other DNF reason |
| **Points earned** | Championship points awarded for the race |

### How it compares

This Actor focuses on season race results from Racing Reference, while the competitors listed below target driver profiles or combine multiple racing series.

| Feature | ParseForge | NASCAR Driver Stats Scraper | Racing Reference Scraper - NASCAR, IndyCar & ARCA Race Results |
|---|---|---|---|
| Season race results | Yes, full season for a single series | Not listed | Yes |
| Driver career stats | Not listed | Yes | Yes |
| Finish, start, laps, status, points per race | Yes | Not listed | Not listed |
| ARCA series support | Yes | Yes | Yes |
| IndyCar results | Not listed | Not listed | Yes |
| No API key required | Yes | Not listed | Not listed |

### Configure the run

Drive the Actor with a season year and a series, and set a maximum number of race results to collect. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "year": "2024"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "year": "2024"
}
```

### Pricing

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

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.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 [NASCAR Racing Reference Season Stats Scraper](https://apify.com/parseforge/nascar-racing-reference-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 Racing Reference 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/nascar-racing-reference-scraper"
```

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

### Troubleshooting

**Why am I getting no results?**

Check that the year you entered has results for the series you selected. Some series did not exist in early years. Also confirm the year is a four-digit string like '2024'.

**The run stopped early and I only got a few races.**

Increase the 'Maximum race results' input. A full season with 40 drivers per race can exceed a low limit. Set it to at least 2000 for a complete season.

**Some races are missing from the output.**

Racing Reference may list a race but not have full results posted yet. Wait a day after the race and retry. If the problem persists, check the year and series combination.

**The Actor is timing out on large seasons.**

Raise the Actor's timeout in the run settings. For seasons with many races, a 300-second timeout is usually enough.

**I see a 'Cannot read properties of undefined' error.**

This usually means Racing Reference changed their page layout. Report the issue on the Actor's Apify page so the maintainer can update the scraper.

### FAQ

| Question | Answer |
|---|---|
| What series can I scrape? | You can scrape the Cup Series, Xfinity Series, Truck Series, and ARCA Menards Series. Select the series from the input dropdown. |
| How far back does the data go? | Racing Reference has race results going back to the first NASCAR season in 1949. Enter any four-digit year in the input. |
| Does this scrape practice or qualifying results? | No, this Actor scrapes race results only. It collects finish, start, laps, status, and points for each driver in a season's races. |
| Can I scrape multiple series at once? | Each run scrapes one series. To scrape multiple series, run the Actor once per series with the same year. |
| What format does the output come in? | You can export your dataset as CSV, JSON, Excel, or XML from the Apify dataset tab. |
| Does this include driver career stats? | No, this Actor scrapes season race results, not driver profile pages. For career stats, see the NASCAR Driver Stats Scraper on Apify Store. |
| Is there a limit on how many results I can scrape? | You set the maximum number of race results per run, up to 1,000,000. A full 36-race Cup season with 40 drivers is about 1,440 rows. |
| Do I need a Racing Reference account? | No. This Actor reads the public Racing Reference pages directly. No login, no API key, no registration. |
| Can I filter by track type or driver? | The Actor scrapes a full season and returns all results. You can filter by track or driver after export using your own tools. |
| How often is the data updated? | Racing Reference updates results shortly after each race. Run the Actor on demand to get the latest completed race. |

### 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 Racing Reference. 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

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

How many race results to collect per run.

## `year` (type: `string`):

Four-digit year (e.g. 2024).

## `series` (type: `string`):

Series

## Actor input object example

```json
{
  "maxItems": 10,
  "year": "2024",
  "series": "W"
}
```

# 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,
    "year": "2024"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nascar-racing-reference-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,
    "year": "2024",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nascar-racing-reference-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,
  "year": "2024"
}' |
apify call parseforge/nascar-racing-reference-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/nascar-racing-reference-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/2Dcz8oZ7Fajiw3q9Y/builds/IXviQkd8foRqaAzT6/openapi.json