# PrizePicks Player Props Scraper (`automation-lab/prizepicks-player-props-scraper`) Actor

Snapshot current PrizePicks projections with normalized player, team, league, game, stat, line, wager, odds, status, promotion, and timing fields. Filter locally for recurring analysis, comparison, history, and alerts.

- **URL**: https://apify.com/automation-lab/prizepicks-player-props-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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

## PrizePicks Player Props Scraper

Snapshot the current public PrizePicks projection board as normalized JSON records.

The Actor fetches the board once, joins PrizePicks JSON:API relationships, applies your filters locally, and exports current player props to the default dataset.

Use it to collect changing lines for fantasy research, line comparison, sports-data products, historical snapshots, and alert pipelines.

### What does PrizePicks Player Props Scraper do?

Each run collects the current public PrizePicks projection board.

It returns one record per matching projection with:

- player, team, and position;
- league and game context;
- stat type and current line score;
- allowed wager types;
- pre-game or live status;
- standard, adjusted, promo, and refund flags;
- trending count and rank;
- start, board, update, and scrape timestamps.

The Actor makes one bulk source request per successful run.

It does not make one request per player or projection.

Filters are evaluated after the full board is received, so combining filters does not multiply source traffic.

### Who is it for?

#### Fantasy analysts

Export current player lines into notebooks, spreadsheets, or statistical models.

#### Odds and line-comparison products

Normalize PrizePicks projections beside other fantasy or sportsbook sources.

#### Sports-data teams

Feed current projection records into internal APIs, dashboards, and warehouses.

#### Alert and history pipelines

Schedule recurring snapshots and detect line, status, odds-type, or ranking changes downstream.

#### Automation builders

Connect the dataset to Make, Zapier, webhooks, Google Sheets, or another Apify Actor.

### Why use this Actor?

- **One bulk request:** minimizes source load and proxy transfer.
- **Structured endpoint:** avoids browser rendering and page selectors.
- **Joined records:** player, league, game, stat, and projection-type resources are resolved for you.
- **Typed output:** stable normalized fields work in JSON, CSV, Excel, and API integrations.
- **Local filters:** filter leagues, players, teams, stats, statuses, and live scope without extra source calls.
- **Stable deduplication:** duplicate JSON:API resources are removed by projection ID.
- **Bounded retries:** blocked sessions, rate limits, transient network failures, and server errors use conservative retry handling.

This Actor is an independent data-extraction tool and is not affiliated with or endorsed by PrizePicks.

### What PrizePicks data can I extract?

| Field | Meaning |
| --- | --- |
| `projectionId` | Unique PrizePicks projection ID |
| `playerId` | Joined PrizePicks player ID |
| `playerName` | Player or matchup participant name |
| `team` | Team name or abbreviation when available |
| `position` | Player position when available |
| `leagueId` | Joined league ID |
| `league` | League name or abbreviation |
| `gameId` | Joined PrizePicks game ID |
| `game` | Matchup, external game ID, or game label |
| `statType` | Source stat type |
| `statDisplayName` | Human-readable stat label |
| `lineScore` | Current projection line |
| `description` | PrizePicks projection description |
| `status` | Current projection status |
| `isLive` | Whether the projection is live |
| `allowedWagerTypes` | Allowed wager sides/types when supplied |
| `oddsType` | Standard or another odds classification |
| `projectionType` | Projection type, such as Single Stat |
| `isPromo` | Promotion flag |
| `refundable` | Refundability flag |
| `trendingCount` | Current source trending count |
| `rank` | Current board rank |
| `startTime` | Scheduled start time |
| `boardTime` | Time the projection entered the board |
| `updatedAt` | Last source update time |
| `scrapedAt` | Time this Actor collected the snapshot |
| `raw` | Optional raw projection resource |

Fields can be `null` when PrizePicks does not supply that relationship or attribute.

### How to scrape PrizePicks player props

1. Open the Actor in Apify Console.
2. Leave all filters empty for a broad current-board snapshot.
3. Optionally enter league, player, team, stat, or status filters.
4. Set `maxItems` to the maximum number of matching projections to save.
5. Click **Start**.
6. Open the default dataset to preview or download JSON, CSV, Excel, XML, or RSS.
7. For recurring analysis, create an Apify schedule and send dataset results to your storage or alert workflow.

The prefilled WNBA input is ready to run.

No PrizePicks login, cookie, or API key is required.

The Actor manages its required Apify proxy automatically.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `leagues` | string\[] | `[]` | Case-insensitive league name, abbreviation, or ID filters |
| `players` | string\[] | `[]` | Case-insensitive partial player-name filters |
| `teams` | string\[] | `[]` | Case-insensitive team name or code filters |
| `stats` | string\[] | `[]` | Case-insensitive stat-name filters |
| `statuses` | string\[] | `[]` | Case-insensitive projection-status filters |
| `liveOnly` | boolean | `false` | Save only projections marked live |
| `includeRaw` | boolean | `false` | Add the raw JSON:API projection resource |
| `maxItems` | integer | `100` | Save 1–10,000 matching projections |
| `maxRetries` | integer | `3` | Allow 1–5 bounded source attempts |

Multiple values inside one filter use OR matching.

Different filter fields combine with AND matching.

For example, `leagues: ["WNBA"]` and `stats: ["Points", "Rebounds"]` means WNBA projections whose stat contains Points or Rebounds.

### Input examples

#### Broad current-board snapshot

```json
{
  "maxItems": 100
}
```

#### WNBA points and rebounds

```json
{
  "leagues": ["WNBA"],
  "stats": ["Points", "Rebounds"],
  "maxItems": 250
}
```

#### Live alert snapshot with raw projection resources

```json
{
  "liveOnly": true,
  "includeRaw": true,
  "maxItems": 1000
}
```

### Output example

The following representative record was collected from the current board during local validation:

```json
{
  "sourceUrl": "https://partner-api.prizepicks.com/projections?per_page=10&single_stat=false",
  "projectionId": "13328226",
  "playerId": "212537",
  "playerName": "Colton Smith",
  "team": "Colton Smith",
  "position": "Player",
  "leagueId": "5",
  "league": "TENNIS",
  "gameId": "175156",
  "game": null,
  "statType": "Fantasy Score",
  "statDisplayName": "Fantasy Score",
  "lineScore": 22,
  "status": "pre_game",
  "isLive": false,
  "allowedWagerTypes": [],
  "oddsType": "standard",
  "projectionType": "Fantasy Score",
  "isPromo": false,
  "refundable": true,
  "trendingCount": 19789,
  "rank": 1,
  "startTime": "2026-07-26T01:00:00.000-04:00",
  "updatedAt": "2026-07-25T23:55:14.820-04:00",
  "scrapedAt": "2026-07-26T04:58:48.372Z"
}
```

The default dataset is the primary output for API clients and integrations.

### How much does it cost to scrape PrizePicks player props?

The Actor uses pay-per-event pricing:

- a **$0.005 start fee** per run;
- a per-saved-projection price based on your Apify plan tier.

| Plan tier | Price per saved projection |
| --- | ---: |
| Free | $0.000041071 |
| Bronze | $0.000035714 |
| Silver | $0.000027857 |
| Gold | $0.000021429 |
| Platinum | $0.000014286 |
| Diamond | $0.000010000 |

On the Free tier, a run saving 100 projections costs about **$0.0091**.

A run saving 1,000 projections costs about **$0.0461** on Free or **$0.0150** on Diamond, including the start fee.

A no-result run pays only the start fee because rejected and unmatched records are not charged as items.

Actual item count depends on the current board and your filters.

### Tips for reliable recurring snapshots

- Keep the default three attempts unless you need stricter one-attempt failure behavior.
- Schedule snapshots at a frequency appropriate for your analysis and source load.
- Store `projectionId`, `lineScore`, `status`, `oddsType`, and `updatedAt` to compare changes.
- Use `scrapedAt` as the snapshot ingestion timestamp.
- Use specific filters to reduce dataset size, not source request count.
- Enable `includeRaw` only when you need source-specific fields outside the normalized schema.
- Expect the current board composition to change by sport calendar and time of day.

### Limits and failure behavior

PrizePicks can change its public endpoint, attributes, relationships, or access controls.

The Actor validates HTTP status, JSON content type, and the expected JSON:API shape.

A challenge page or malformed response fails the run instead of silently returning an empty dataset.

HTTP 403, HTTP 429, transient network errors, and server errors can trigger bounded session retirement and backoff.

Malformed input fails before source collection.

`maxItems` limits saved matching records; it does not change the upstream bulk-board scope.

A successful empty dataset means no current projections matched all supplied filters.

### Recurring line-history workflow

1. Schedule the Actor every 15, 30, or 60 minutes.
2. Export each run's default dataset to your database or object store.
3. Use `projectionId` as the entity key.
4. Compare `lineScore`, `status`, `oddsType`, `rank`, and `updatedAt` with the previous snapshot.
5. Trigger an alert when your threshold or status rule matches.
6. Retain `scrapedAt` so observations remain ordered even when source update timestamps match.

This workflow is useful for research and monitoring; it does not place wagers or provide betting advice.

### Integrations

#### Google Sheets and CSV

Download the default dataset as CSV or connect an Apify integration to a spreadsheet workflow.

#### Webhooks

Attach a run-succeeded webhook and pass the default dataset ID to your ingestion service.

#### Make and Zapier

Start the Actor from an automation scenario, wait for completion, and iterate over dataset items.

#### Data warehouses

Use the Apify API to stream JSON items into BigQuery, Snowflake, PostgreSQL, or another warehouse.

#### Other Apify Actors

Pass normalized records to deduplication, transformation, monitoring, or notification Actors.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~prizepicks-player-props-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"leagues":["WNBA"],"stats":["Points"],"maxItems":100}'
```

To wait for completion and receive dataset items directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~prizepicks-player-props-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":25}'
```

### Run with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/prizepicks-player-props-scraper').call({
  leagues: ['WNBA'],
  stats: ['Points', 'Rebounds'],
  maxItems: 250,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/prizepicks-player-props-scraper').call(run_input={
    'leagues': ['WNBA'],
    'stats': ['Points', 'Rebounds'],
    'maxItems': 250,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use through MCP

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/prizepicks-player-props-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use the equivalent MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/prizepicks-player-props-scraper"
    }
  }
}
```

Example prompts:

After connecting through MCP, ask your agent:

- "Use the PrizePicks Player Props Scraper MCP tool to get up to 100 current WNBA points projections."
- "Snapshot current live PrizePicks projections and return player, stat, line, and update time."
- "Collect NFL passing and receiving projections for my line-history pipeline."

### Responsible use and legality

This Actor accesses publicly available projection data without logging in.

You are responsible for complying with applicable law, PrizePicks terms, Apify terms, and restrictions that apply to your location and use case.

Use conservative schedules and avoid attempts to bypass account, geographic, age, or legal restrictions.

Do not use the output for harassment, deceptive practices, market manipulation, or unlawful gambling activity.

The data is informational and can change after collection.

Nothing in the output is financial, gambling, or legal advice.

### Troubleshooting

#### Why did my run return no records?

The current board may not contain records matching every filter. Remove filters one at a time, start with a broad `maxItems: 25` run, and remember that different filter fields combine with AND logic.

#### Why did the source request fail?

PrizePicks sometimes blocks a proxy identity or rate-limits requests. Keep `maxRetries` at 3 so the Actor can retire a blocked session and retry conservatively. If all attempts fail, wait before rerunning rather than launching many parallel requests.

#### Why is a field null?

Some projections do not include every relationship or attribute. The Actor preserves the projection and uses `null` rather than inventing missing metadata.

#### Why is `allowedWagerTypes` empty?

PrizePicks does not supply this attribute on every projection. An empty array means no values were present in that source record.

#### Does `maxItems` reduce proxy traffic?

No. The source returns a bulk board. `maxItems` controls saved matching records after the fetch.

### FAQ

#### Does this Actor require a PrizePicks account?

No. It collects the anonymous public projection board.

#### Does it require users to configure a proxy?

No. The Actor manages the required Apify SHADER proxy session internally.

#### Does it scrape web pages with a browser?

No. It uses the structured PrizePicks JSON:API response, reducing compute and avoiding page-selector fragility.

#### Can I filter multiple leagues or players?

Yes. Values within each filter are matched with OR logic.

#### Can I collect more than 100 records?

Yes. Raise `maxItems` up to 10,000. The current source board and filters determine the actual count.

#### Can I use this for historical data?

The source provides a current snapshot. Create a schedule and store successive datasets to build your own observation history.

#### Can this Actor place picks or wagers?

No. It only exports public projection data.

### Related Actors

- [Underdog Fantasy Player Props Scraper](https://apify.com/automation-lab/underdog-fantasy-player-props-scraper) — collect comparable current pick'em lines from a separate fantasy source.
- [Dataset Dedup](https://apify.com/automation-lab/dataset-dedup) — remove duplicate records before downstream export.

Use separate source Actors when building a multi-source comparison pipeline; do not treat similar player names or stat labels as guaranteed equivalent markets.

### Support

If a field or source response changes, open an Actor issue with:

- the run ID;
- a redacted input;
- the expected behavior;
- the observed status or missing field.

Do not include Apify tokens, cookies, personal information, or other credentials.

# Actor input Schema

## `leagues` (type: `array`):

Only include exact league names, abbreviations, or IDs, such as WNBA, NFL, MLB, NHL, or CS2.

## `players` (type: `array`):

Only include player names containing one of these values. Partial names are supported.

## `teams` (type: `array`):

Only include player team names or codes containing one of these values.

## `stats` (type: `array`):

Only include stat names containing one of these values, such as points, rebounds, or passing yards.

## `statuses` (type: `array`):

Only include projection statuses containing one of these values.

## `liveOnly` (type: `boolean`):

Only save projections marked live by PrizePicks.

## `includeRaw` (type: `boolean`):

Include the source JSON:API projection resource in each normalized record for advanced workflows.

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

Maximum number of matching projection records to save.

## `maxRetries` (type: `integer`):

Maximum bounded attempts for blocked proxy sessions, rate limits, transient network errors, or server errors.

## Actor input object example

```json
{
  "leagues": [
    "WNBA"
  ],
  "players": [],
  "teams": [],
  "stats": [],
  "statuses": [],
  "liveOnly": false,
  "includeRaw": false,
  "maxItems": 20,
  "maxRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Normalized current PrizePicks projection records in the default dataset overview view.

# 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 = {
    "leagues": [
        "WNBA"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/prizepicks-player-props-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 = {
    "leagues": ["WNBA"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/prizepicks-player-props-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 '{
  "leagues": [
    "WNBA"
  ],
  "maxItems": 20
}' |
apify call automation-lab/prizepicks-player-props-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/prizepicks-player-props-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PrizePicks Player Props Scraper",
        "description": "Snapshot current PrizePicks projections with normalized player, team, league, game, stat, line, wager, odds, status, promotion, and timing fields. Filter locally for recurring analysis, comparison, history, and alerts.",
        "version": "0.1",
        "x-build-id": "CV8nYXDLQE7JDK9Oj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~prizepicks-player-props-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-prizepicks-player-props-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/automation-lab~prizepicks-player-props-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-prizepicks-player-props-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/automation-lab~prizepicks-player-props-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-prizepicks-player-props-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": {
                    "leagues": {
                        "title": "Leagues",
                        "type": "array",
                        "description": "Only include exact league names, abbreviations, or IDs, such as WNBA, NFL, MLB, NHL, or CS2.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "players": {
                        "title": "Players",
                        "type": "array",
                        "description": "Only include player names containing one of these values. Partial names are supported.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "teams": {
                        "title": "Teams",
                        "type": "array",
                        "description": "Only include player team names or codes containing one of these values.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "stats": {
                        "title": "Stat types",
                        "type": "array",
                        "description": "Only include stat names containing one of these values, such as points, rebounds, or passing yards.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Statuses",
                        "type": "array",
                        "description": "Only include projection statuses containing one of these values.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "liveOnly": {
                        "title": "Live projections only",
                        "type": "boolean",
                        "description": "Only save projections marked live by PrizePicks.",
                        "default": false
                    },
                    "includeRaw": {
                        "title": "Include raw projection",
                        "type": "boolean",
                        "description": "Include the source JSON:API projection resource in each normalized record for advanced workflows.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching projection records to save.",
                        "default": 100
                    },
                    "maxRetries": {
                        "title": "Maximum request attempts",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum bounded attempts for blocked proxy sessions, rate limits, transient network errors, or server errors.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```