# Equibase Horse Racing Scraper - US Race Entries & Results (`jungle_synthesizer/equibase-us-horse-racing-scraper`) Actor

Scrape US Thoroughbred horse racing data from Equibase.com — the official source for North American racing. Extract race entries (horses, jockeys, trainers, odds) and results (finish order, times, payouts) for any date and track. Ideal for handicappers and sports analytics.

- **URL**: https://apify.com/jungle\_synthesizer/equibase-us-horse-racing-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Sports, Business
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Equibase Horse Racing Scraper - US Race Entries & Results

Scrapes race entries and results from Equibase.com — the official statistics provider for North American Thoroughbred racing. Returns structured race card data: horses, jockeys, trainers, morning-line odds, finish order, times, and pari-mutuel payouts.

### What It Extracts

- Race entries: post position, horse name, jockey, trainer, owner, weight, morning-line odds
- Race results: finish order, winning time, margins, win/place/show payouts
- Exotic payouts: exacta, trifecta, superfecta, pick 3/4/5/6
- Race conditions: type (Maiden/Allowance/Stakes/Claiming), distance, surface, purse, track condition
- Coverage: any US Thoroughbred track on any date with public results

### How It Works

1. You provide a race date and optional track code filter
2. The scraper navigates Equibase's entry and result pages using a real browser session
3. Race card data is parsed and returned as one record per race
4. Results (finish order, payouts) are attached when available for past races

Equibase protects its data pages with Imperva bot detection. The scraper uses residential proxy rotation and browser-based rendering to pass that check. Residential proxies are required — datacenter IPs get the "Pardon Our Interruption" page every time.

### Input Configuration

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `raceDate` | String | Today | Date to scrape — MM/DD/YYYY format. Leave blank for today's card. Use a past date for completed results. |
| `trackCodes` | Array | All tracks | Optional filter by track code (AQU, CD, SA, GP, PRX, etc.). Empty = all tracks running that day. |
| `dataMode` | Select | `both` | `entries` = race cards only; `results` = finish order + payouts; `both` = full data. Results only available for past races. |
| `maxItems` | Integer | 10 | Maximum race records to return. Each race card is one record. |
| `proxyConfiguration` | Object | Residential | Proxy settings. Residential proxy required — datacenter IPs are blocked. |

**Example: Today's entries at Parx Racing**
```json
{
  "sp_intended_usage": "Handicapping research",
  "raceDate": "",
  "trackCodes": ["PRX"],
  "dataMode": "entries",
  "maxItems": 10
}
````

**Example: Yesterday's results at Aqueduct and Churchill Downs**

```json
{
  "sp_intended_usage": "Historical results database",
  "raceDate": "05/10/2026",
  "trackCodes": ["AQU", "CD"],
  "dataMode": "results",
  "maxItems": 20
}
```

**Example: Full card data for all tracks on a given date**

```json
{
  "sp_intended_usage": "Daily racing analytics",
  "raceDate": "05/09/2026",
  "trackCodes": [],
  "dataMode": "both",
  "maxItems": 50
}
```

### Output Schema

One record per race. Fields vary by data mode.

| Field | Type | Description |
|-------|------|-------------|
| `race_id` | String | Unique identifier: `PRX-2026-05-11-R3` |
| `race_date` | String | ISO date: `2026-05-11` |
| `track_code` | String | Short track code: `PRX`, `AQU`, `CD` |
| `track_name` | String | Full track name: `Parx Racing`, `Aqueduct` |
| `race_number` | Number | Race number on the card |
| `race_name` | String | Race name or grade if named (e.g. `Kentucky Derby`) |
| `race_type` | String | Classification: `Maiden`, `Allowance`, `Stakes`, `Claiming` |
| `distance` | String | Distance description: `6 Furlongs`, `1 1/16 Miles` |
| `distance_furlongs` | Number | Distance in furlongs: `6`, `8.5` |
| `surface` | String | `Dirt`, `Turf`, `Synthetic`, `All-Weather` |
| `track_condition` | String | `Fast`, `Good`, `Sloppy`, `Muddy`, `Firm`, `Soft` |
| `purse_usd` | Number | Total purse in USD |
| `post_time` | String | Scheduled post time (local track time) |
| `age_sex_restriction` | String | Eligible horses: `3yo+`, `F&M`, `A` |
| `entries_count` | Number | Number of horses entered |
| `entries` | String | Pipe-delimited entry list: `post\|horse\|jockey\|trainer\|weight\|ml_odds` |
| `results_available` | Boolean | Whether race results exist |
| `winner_horse` | String | Name of the winning horse |
| `winner_jockey` | String | Name of the winning jockey |
| `winner_trainer` | String | Name of the winning trainer |
| `winning_time` | String | Official winning time: `1:23.45` |
| `finish_order` | String | Top finishers: `1. Tulip (2), 2. Hedge Ratio (nk), 3. Boss Sully (hd)` |
| `win_payout` | Number | $2 win payout for the winner |
| `place_payout` | Number | $2 place payout |
| `show_payout` | Number | $2 show payout |
| `exotic_payouts` | String | JSON string with exacta, trifecta, superfecta amounts |
| `entry_url` | String | Direct link to the Equibase entry page |
| `result_url` | String | Direct link to the Equibase result summary page |
| `scraped_at` | String | ISO timestamp of when this record was scraped |

**Sample output (entries mode)**

```json
{
  "race_id": "PRX-2026-05-11-R3",
  "race_date": "2026-05-11",
  "track_code": "PRX",
  "track_name": "Parx Racing",
  "race_number": 3,
  "race_name": null,
  "race_type": "Maiden Claiming",
  "distance": "6 Furlongs",
  "distance_furlongs": 6,
  "surface": "Dirt",
  "track_condition": "Fast",
  "purse_usd": 16000,
  "post_time": "1:15 PM",
  "age_sex_restriction": "3yo+",
  "entries_count": 9,
  "entries": "1|Winning Time|J. Rocco Jr.|K. Magee|122|5/2 | 2|Gordian Knot|C. DeCarlo|J. Servis|120|3/1 | ...",
  "results_available": false,
  "winner_horse": null,
  "winning_time": null,
  "finish_order": null,
  "win_payout": null,
  "exotic_payouts": null,
  "entry_url": "https://www.equibase.com/static/entry/PRX051126USA-EQB.html",
  "result_url": "https://www.equibase.com/static/chart/summary/PRX051126USA-EQB.html",
  "scraped_at": "2026-05-11T10:28:00.000Z"
}
```

### Pricing

$0.10 per run + $0.001 per race record. A single-track card of 9 races costs about $0.11. A full day across 8 tracks (roughly 72 races) runs about $0.17.

### 🔍 FAQ

**How do I scrape Equibase horse racing data?**
Equibase Horse Racing Scraper handles it. Set a date, optionally filter by track code, choose whether you want entries, results, or both, and run it. The output is structured JSON — one record per race.

**What track codes does Equibase use?**
Equibase Horse Racing Scraper accepts standard track abbreviations: `AQU` (Aqueduct), `CD` (Churchill Downs), `SA` (Santa Anita), `GP` (Gulfstream Park), `KEE` (Keeneland), `PRX` (Parx Racing), `BEL` (Belmont Park), and dozens more. Leave `trackCodes` empty to scrape all active tracks on a given day.

**How much does Equibase Horse Racing Scraper cost to run?**
Equibase Horse Racing Scraper costs $0.10 per run plus $0.001 per race record. A single day at one track with 9 races costs $0.11. An all-tracks sweep on a busy Saturday might cover 80+ races for around $0.18.

**Can I get past performance data or PDF charts?**
Equibase Horse Racing Scraper does not access PDF chart files or historical past-performance detail — those are Equibase's paid products and are not available on the public pages. The scraper returns entry and result data from the free public HTML pages: post positions, odds, finish order, times, and payouts.

**Does Equibase Horse Racing Scraper need proxies?**
Yes. Equibase uses Imperva bot protection on all data pages. Residential proxies are required — datacenter IPs receive an interstitial block page instead of race data. The default proxy configuration uses Apify residential proxies, which work correctly.

### Need More Features?

Need custom fields, additional track coverage, or integration with a handicapping database? File an issue or get in touch.

### Why Use Equibase Horse Racing Scraper?

- **First US horse racing actor on Apify** — covers the largest Thoroughbred racing market in the world, which handles roughly $11B in annual wagering and was completely unserved before this
- **Clean output** — returns structured JSON with consistent field names across all tracks and dates, not the raw HTML mess that comes with DIY scraping
- **Flexible data modes** — entries-only for pre-race handicapping, results-only for historical analysis, or both for a complete race-day record

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `raceDate` (type: `string`):

Date to scrape in MM/DD/YYYY format. Defaults to today. Use a recent past date to get completed results.

## `trackCodes` (type: `array`):

Optional list of track codes to filter (e.g. AQU, CD, SA, GP). Leave empty to scrape all tracks running on the selected date.

## `dataMode` (type: `string`):

entries = race cards (horses, jockeys, trainers, odds); results = finish order + payouts; both = entries and results together (results only available for past races).

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

Maximum number of race records to return. Each race card counts as one record.

## `proxyConfiguration` (type: `object`):

Proxy settings. Residential proxy required to bypass Equibase bot protection.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "trackCodes": [],
  "dataMode": "both",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "raceDate": "",
    "trackCodes": [],
    "dataMode": "both",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/equibase-us-horse-racing-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "raceDate": "",
    "trackCodes": [],
    "dataMode": "both",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/equibase-us-horse-racing-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "raceDate": "",
  "trackCodes": [],
  "dataMode": "both",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call jungle_synthesizer/equibase-us-horse-racing-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/equibase-us-horse-racing-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Equibase Horse Racing Scraper - US Race Entries & Results",
        "description": "Scrape US Thoroughbred horse racing data from Equibase.com — the official source for North American racing. Extract race entries (horses, jockeys, trainers, odds) and results (finish order, times, payouts) for any date and track. Ideal for handicappers and sports analytics.",
        "version": "0.1",
        "x-build-id": "m5Iz99z2j2iWFeiEG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~equibase-us-horse-racing-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-equibase-us-horse-racing-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/jungle_synthesizer~equibase-us-horse-racing-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-equibase-us-horse-racing-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/jungle_synthesizer~equibase-us-horse-racing-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-equibase-us-horse-racing-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",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "raceDate": {
                        "title": "Race Date",
                        "type": "string",
                        "description": "Date to scrape in MM/DD/YYYY format. Defaults to today. Use a recent past date to get completed results."
                    },
                    "trackCodes": {
                        "title": "Track Codes",
                        "type": "array",
                        "description": "Optional list of track codes to filter (e.g. AQU, CD, SA, GP). Leave empty to scrape all tracks running on the selected date.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataMode": {
                        "title": "Data Mode",
                        "enum": [
                            "entries",
                            "results",
                            "both"
                        ],
                        "type": "string",
                        "description": "entries = race cards (horses, jockeys, trainers, odds); results = finish order + payouts; both = entries and results together (results only available for past races).",
                        "default": "both"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of race records to return. Each race card counts as one record.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy required to bypass Equibase bot protection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
