# Pro Football Reference Scraper | NFL Stats and History (`parseforge/pro-football-reference-scraper`) Actor

Pull NFL player, team, and game data from Pro Football Reference including box scores, season stats, advanced metrics, standings, draft history, and historical records. Built for football analytics, fantasy NFL tools, betting models, and deep sports research at scale.

- **URL**: https://apify.com/parseforge/pro-football-reference-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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)

## 🏈 Pro Football Reference Stats Scraper

> 🚀 **Export NFL player statistics in seconds.** Get passing, rushing, receiving, and defense stats for any season from pro-football-reference.com - no account needed.

> 🕒 **Last updated:** 2026-05-22 · **📊 19 fields** per record · **All NFL seasons** · **Passing, rushing, receiving, defense**

The Pro Football Reference Stats Scraper extracts NFL player statistics from [pro-football-reference.com](https://www.pro-football-reference.com), the definitive source for professional football historical data. Choose a season and stat type to export complete player stat lines including yards, touchdowns, games played, and more.

Coverage spans every NFL season, all 32 teams, and four stat categories: passing, rushing, receiving, and defense. Each record includes the player name, team, position, game counts, and all relevant statistics for the chosen category.

**Target Audience / Use Cases**

| Who | Why |
|-----|-----|
| Sports analysts | Build season-over-season performance models |
| Fantasy football players | Research player stats and trends |
| Data journalists | Power articles with real NFL data |
| Sports bettors | Inform player prop research |
| Researchers | Study NFL performance patterns |
| Developers | Build NFL stats apps and dashboards |

### 📋 What the Pro Football Reference Scraper does

- Scrapes NFL player statistics from pro-football-reference.com for any season
- Supports four stat categories: passing, rushing, receiving, and defense
- Returns all players ranked by the selected stat category for that season
- Automatically retrieves the most recent archived snapshot for complete end-of-season data
- Extracts player URLs for deep-linking to individual player pages
- Free users get a 10-item preview; paid users can extract up to 1,000,000 records

> 💡 **Why it matters:** Pro Football Reference is the gold standard for NFL historical data. This scraper gives you programmatic access to decades of player statistics without manual copy-paste.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `season` | string | `2024` | NFL season year (e.g. 2024, 2023, 2010) |
| `statType` | select | `passing` | Stat category: passing, rushing, receiving, defense |
| `maxItems` | integer | 10 | Max records to return (free: capped at 10, paid: up to 1,000,000) |

**Example - Passing stats for 2024:**
```json
{
  "season": "2024",
  "statType": "passing",
  "maxItems": 50
}
````

**Example - Rushing stats for 2023:**

```json
{
  "season": "2023",
  "statType": "rushing",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Stats are sorted by the primary stat for each category (passing yards for passing, rushing yards for rushing). Null fields for non-applicable stats (e.g. `passingYards` is null for rushing stat type) are expected - only the relevant category fields are populated.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🏷️ `playerName` | string | Full player name |
| 🔑 `playerId` | string | Player ID from pro-football-reference.com |
| 🏟️ `team` | string | NFL team abbreviation (e.g. CIN, DET) |
| 📍 `position` | string | Player position (QB, RB, WR, LB, etc.) |
| 📅 `season` | integer | NFL season year |
| 📊 `statType` | string | Stat category (passing/rushing/receiving/defense) |
| 🎮 `gamesPlayed` | integer | Games played |
| 🎮 `gamesStarted` | integer | Games started |
| 🎯 `passingYards` | integer | Passing yards (passing only) |
| 🏆 `passingTDs` | integer | Passing touchdowns (passing only) |
| 🚫 `interceptions` | integer | Interceptions thrown (passing) or caught (defense) |
| 🏃 `rushingYards` | integer | Rushing yards (rushing only) |
| 🏆 `rushingTDs` | integer | Rushing touchdowns (rushing only) |
| 📡 `receivingYards` | integer | Receiving yards (receiving only) |
| 🏆 `receivingTDs` | integer | Receiving touchdowns (receiving only) |
| 🛡️ `tackles` | integer | Total tackles (defense only) |
| 💥 `sacks` | number | Sacks (defense only) |
| 🔗 `playerUrl` | string | URL to player page on pro-football-reference.com |
| 🕒 `scrapedAt` | string | ISO timestamp of scrape |
| ❌ `error` | string | Error message if scraping failed |

**Sample records (2024 passing stats):**

```json
[
  {
    "playerName": "Joe Burrow",
    "playerId": "B/BurrJo01",
    "team": "CIN",
    "position": "QB",
    "season": 2024,
    "statType": "passing",
    "gamesPlayed": 17,
    "gamesStarted": 17,
    "passingYards": 4918,
    "passingTDs": 43,
    "interceptions": 9,
    "rushingYards": null,
    "rushingTDs": null,
    "receivingYards": null,
    "receivingTDs": null,
    "tackles": null,
    "sacks": null,
    "playerUrl": "https://www.pro-football-reference.com/players/B/BurrJo01.htm",
    "scrapedAt": "2026-05-22T03:43:52.088Z",
    "error": null
  },
  {
    "playerName": "Jared Goff",
    "playerId": "G/GoffJa00",
    "team": "DET",
    "position": "QB",
    "season": 2024,
    "statType": "passing",
    "gamesPlayed": 17,
    "gamesStarted": 17,
    "passingYards": 4629,
    "passingTDs": 37,
    "interceptions": 12,
    "rushingYards": null,
    "rushingTDs": null,
    "receivingYards": null,
    "receivingTDs": null,
    "tackles": null,
    "sacks": null,
    "playerUrl": "https://www.pro-football-reference.com/players/G/GoffJa00.htm",
    "scrapedAt": "2026-05-22T03:43:52.088Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Detail |
|---------|--------|
| 🏈 All stat categories | Passing, rushing, receiving, defense in one actor |
| 📅 All seasons | Any NFL season from the historical archive |
| 🔗 Player deep links | Direct URLs to individual player pages |
| ⚡ Fast | Results in seconds via archive-based fetch |
| 🆓 Free preview | 10 records free, no account required |
| 🌐 No login needed | Public data, no credentials required |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Sports APIs |
|---------|-----------|-------------------|-------------|
| All seasons | ✅ | ✅ | Varies |
| Free tier | ✅ 10 records | ✅ | Usually no |
| Programmatic access | ✅ | ❌ | ✅ |
| JSON/CSV export | ✅ | ❌ | ✅ |
| No API key needed | ✅ | ✅ | ❌ |
| Historical data | ✅ | ✅ | Varies |

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (comes with $5 free credit)
2. Open the [Pro Football Reference Stats Scraper](https://apify.com/parseforge/pro-football-reference-scraper)
3. Set your `season` (e.g. `2024`) and `statType` (e.g. `passing`)
4. Set `maxItems` to control how many records you want
5. Click **Start** and wait a few seconds
6. Download your data as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Fantasy Football Research

Pull rushing and receiving stats for any season to evaluate player performance, identify breakout candidates, or build custom scoring models for your fantasy league.

#### Sports Media and Journalism

Export passing stats sorted by yards or touchdowns to power data-driven articles, infographics, and comparison pieces without manual data entry.

#### Historical Performance Analysis

Compare QBs across multiple seasons by running the scraper for different years and merging the datasets. Build decade-spanning performance timelines.

#### Sports Betting Research

Extract defense stats including sacks and interceptions to model defensive strength and inform player prop or team total bets.

### 🔌 Automating Pro Football Reference Scraper

Integrate this actor with your favorite tools using Apify native integrations:

- **Make (Integromat)** - Trigger on a schedule, send results to Google Sheets
- **Zapier** - Push new stats to Slack, Airtable, or Notion
- **Webhooks** - POST dataset results to your own API endpoint
- **Apify API** - Call directly from your codebase with the REST API

### 🌟 Beyond business use cases

#### Research and Academia

Study positional evolution in the NFL - how has the passing game changed over 20 years? This scraper gives you the raw data to find out.

#### Creative Projects

Build a "guess the player" game using historical stat lines, or generate AI-powered game recaps from raw stat data.

#### Non-profit and Education

Coaches and sports science programs can use historical NFL data to teach performance analysis concepts with real data.

#### Personal Projects

Build your own fantasy football draft tool, a personal stat tracker dashboard, or a historical NFL trivia bot.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant (ChatGPT, Claude, Gemini) questions like:

- "What passing stats does this scraper return for 2024?"
- "How do I get rushing stats for multiple seasons?"
- "Which fields are null for defense stat type?"
- "How do I export this data to Excel?"

### ❓ Frequently Asked Questions

**🏈 What seasons are available?**
All NFL seasons available on pro-football-reference.com, typically from the 1970s to the most recently completed season.

**📊 What stat types are supported?**
Four stat types: `passing` (QBs), `rushing` (RBs/QBs), `receiving` (WRs/TEs/RBs), and `defense` (defensive players).

**🔢 How many players are returned?**
All players with stats for that season sorted by the primary stat. Typically 30-50 for passing, 100+ for rushing/receiving.

**❓ Why are some fields null?**
Stat-specific fields are null when not applicable. `passingYards` is null for rushing stats, `tackles` is null for passing stats, etc. This is by design.

**📅 Is 2024 season data available?**
Yes - the 2024 season ended in early 2025 and is fully archived.

**🆓 What do free users get?**
Free users get up to 10 records per run as a preview. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) for full datasets.

**💰 How much does it cost?**
[Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 credit. Full season stats typically cost a few cents per run.

**🔄 How fresh is the data?**
Data comes from the most recently archived snapshot of pro-football-reference.com, typically within days of the latest update.

**🌐 Do I need an account on pro-football-reference.com?**
No - this scraper accesses public data only, no account needed on either end.

**📁 What export formats are available?**
JSON, CSV, Excel (XLSX), and XML via the Apify dataset export.

**🔗 Can I get player profile URLs?**
Yes - every record includes a `playerUrl` field linking directly to the player page on pro-football-reference.com.

**🏟️ Are team names included?**
Yes - the `team` field contains the 3-letter NFL team abbreviation (e.g. CIN, DET, MIN).

### 🔌 Integrate with any app

Connect this actor to your workflow using:

- **Google Sheets** - via Make or Zapier integration
- **Airtable** - via Zapier webhook trigger
- **Slack** - send stat summaries on a schedule
- **Notion** - build a living NFL database
- **REST API** - call the Apify API from any language
- **Python / Node.js** - use the official Apify SDK
- **Excel** - download CSV and open directly

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [parseforge/bstock-scraper](https://apify.com/parseforge/bstock-scraper) | B-Stock wholesale marketplace listings |
| [parseforge/dicks-sporting-goods-scraper](https://apify.com/parseforge/dicks-sporting-goods-scraper) | Dick's Sporting Goods product catalog |
| [parseforge/carsdb-scraper](https://apify.com/parseforge/carsdb-scraper) | Cars database listings and pricing |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data scrapers across sports, finance, jobs, and more.

***

**Disclaimer:** This actor accesses publicly available data from pro-football-reference.com via archived snapshots. Use responsibly and in accordance with the website terms of service. ParseForge is not affiliated with Sports Reference LLC or pro-football-reference.com.

# Actor input Schema

## `season` (type: `string`):

NFL season year to scrape (e.g. 2024, 2023, 2022)

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

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

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pro Football Reference Scraper | NFL Stats and History",
        "description": "Pull NFL player, team, and game data from Pro Football Reference including box scores, season stats, advanced metrics, standings, draft history, and historical records. Built for football analytics, fantasy NFL tools, betting models, and deep sports research at scale.",
        "version": "0.1",
        "x-build-id": "1lGNNSuhTYx6j3wgh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~pro-football-reference-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-pro-football-reference-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~pro-football-reference-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-pro-football-reference-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~pro-football-reference-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-pro-football-reference-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": {
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "NFL season year to scrape (e.g. 2024, 2023, 2022)",
                        "default": "2024"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
