# Sleeper Player Props Scraper (`solidcode/sleeper-player-props-scraper`) Actor

\[💰 $0.05 / 1K] Extract Sleeper pick'em player prop lines across NBA, NFL, MLB, NHL, soccer, PGA, MMA, tennis, CS2 and more. Get over/under lines, payout multipliers, pick popularity, injury status, game context, and recent performance per line.

- **URL**: https://apify.com/solidcode/sleeper-player-props-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 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

## Sleeper Player Props Scraper

Pull Sleeper pick'em player prop lines at scale — projected over/under lines, over & under payout multipliers, community pick popularity, injury status, external player IDs, and full game & venue context across every in-season Sleeper league. One clean row per prop line, straight to JSON, CSV, or your spreadsheet. Built for sports bettors, DFS players, props modelers, and odds aggregators who need live Sleeper pick'em lines in a structured feed without tapping through the app one player at a time.

### Why This Scraper?

- **Over and under payout multipliers on every line** — the exact `overMultiplier` and `underMultiplier` Sleeper is offering, cast to clean numbers, so you can compute implied edge instantly.
- **Community pick popularity, quantified** — `pickPopularity` plus raw over / under / total pick counts (`pickCountOver`, `pickCountUnder`, `pickCountTotal`) on each line, so you can see where the public money is leaning.
- **11 league options in one run** — NBA, NFL, MLB, NHL, WNBA, PGA golf, MMA, tennis, CS2 esports, plus international soccer (a full soccer umbrella that catches every competition Sleeper opens, and a dedicated World Cup filter) — pick one, several, or "All leagues".
- **External player IDs for cross-referencing** — a Sportradar ID on virtually every player, plus ESPN, Yahoo, Rotowire, and FantasyData IDs wherever Sleeper carries them (coverage is fullest for NFL and NBA), so you can join Sleeper players to your existing stats and odds sources.
- **10-game recent performance history embedded per line** — a `recentPerformance` array of the player's last outings (date, opponent, actual value) attached to each prop, so you can back-test a line without a second lookup.
- **Full game & venue context for team sports** — game start time, home/away teams with names and season records, TV channel, venue name/city/state, and the Sportradar game ID join key (populates for team leagues like MLB, WNBA, CS2, and soccer).
- **Injury signal on the line** — `playerInjuryStatus`, `playerInjuryBodyPart`, and `playerInjuryNotes` surface right beside the prop, so a questionable tag never slips past your model.
- **Alternate lines on demand** — flip one toggle to also pull alternate projection targets for the same player and stat, each with its own adjusted multipliers.
- **Filter by league, player, team, or stat type** — partial, case-insensitive matching (e.g. `lebron` matches "LeBron James", `HOU` matches Houston), so a broad board narrows to exactly the slate you're modeling.

### Use Cases

**Sports Betting Research**
- Compare over vs. under payout multipliers to find the side with the better price
- Spot lines where public pick popularity diverges from the multiplier
- Track a specific player's line and multiplier movement before lock
- Build a full board snapshot for a slate in a single run

**DFS & Fantasy**
- Pull projected lines as a baseline for player projections
- Cross-reference injury status before locking a lineup
- Filter to a single stat market (points, hits, strikeouts, goals) across a league
- Use recent performance history to validate a projected line

**Odds Aggregation**
- Feed Sleeper pick'em lines into a multi-book comparison table
- Match players across books using Sportradar, ESPN, Yahoo, Rotowire, or FantasyData IDs
- Snapshot the full multi-league board on a schedule for historical odds archives
- Normalize Sleeper's stat markets into your own schema with the readable `statDisplay` label

**Model Building & Back-testing**
- Join the embedded recent-performance array to a projected line to measure hit rate
- Analyze pick popularity as a contrarian or consensus signal
- Study multiplier structure across stat types and leagues
- Build training datasets that pair a line with its game and venue context

**Market Monitoring**
- Poll the board periodically to catch line and multiplier changes
- Watch which markets Sleeper opens for an upcoming slate
- Detect when a player's status flips to questionable or out
- Track community pick counts building through the day

### Getting Started

#### Pull the Entire Board

The simplest run — every prop line across all in-season leagues:

```json
{
    "leagues": ["all"]
}
````

#### One League, One Stat

Narrow to a single league and stat market:

```json
{
    "leagues": ["mlb"],
    "statTypes": ["Hits", "Strikeouts"]
}
```

#### Track Specific Players and Teams

```json
{
    "leagues": ["nba", "wnba"],
    "playerNames": ["LeBron James", "Caitlin Clark"],
    "teams": ["LAL"],
    "maxResults": 500
}
```

#### Advanced — Alternate Lines, Capped

```json
{
    "leagues": ["mlb", "tennis", "soccer_worldcup"],
    "statTypes": ["Points", "Hits", "Goals"],
    "includeAlternateLines": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `leagues` | array (select) | `["all"]` | Which leagues to pull prop lines for. Choose "All leagues" for everything available, or pick specific ones. Options: All leagues, NBA (Basketball), NFL (Football), MLB (Baseball), NHL (Hockey), WNBA (Basketball), PGA (Golf), MMA, Tennis, CS2 (Esports), Soccer (all competitions), Soccer - World Cup. The "Soccer (all competitions)" option covers whatever soccer competitions Sleeper has live at run time. |

#### Filters

Every filter is optional — leave blank to get the full board for your chosen leagues. Filters trim results after they're collected.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `playerNames` | array | `[]` | Only keep lines for these players. Partial, case-insensitive (e.g. "lebron" matches "LeBron James"). Accepts a comma-separated entry too. |
| `statTypes` | array | `[]` | Only keep these stat markets (e.g. "Points", "Rebounds", "Assists", "Hits", "Goals", "Passing Yards"). Case-insensitive. |
| `teams` | array | `[]` | Only keep lines for these teams. Accepts a team name or abbreviation (e.g. "Lakers" or "LAL"), case-insensitive. |
| `includeAlternateLines` | boolean | `false` | Also include alternate projection lines — different target values for the same player and stat, each with its own adjusted payout multipliers. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `0` | Hard cap on how many prop lines to return. The run stops adding lines once this many are collected. Set to 0 for no limit. |

### Output

One flat row per prop line. Here's a representative MLB result:

```json
{
    "playerName": "Yordan Alvarez",
    "playerTeam": "HOU",
    "playerPosition": "DH",
    "league": "mlb",
    "stat": "bat_hits",
    "statDisplay": "Hits",
    "line": 0.5,
    "overMultiplier": 1.72,
    "underMultiplier": 2.05,
    "lineType": "normal",
    "isAlternate": false,
    "pickPopularity": 0.63,
    "pickCountOver": 812,
    "pickCountUnder": 476,
    "pickCountTotal": 1288,
    "playerInjuryStatus": null,
    "playerSportradarId": "6a9c1f3e-...",
    "playerEspnId": null,
    "playerYahooId": null,
    "playerRotowireId": "14539",
    "playerFantasyDataId": null,
    "gameStart": 1751572800000,
    "homeTeam": "HOU",
    "awayTeam": "SEA",
    "homeTeamName": "Houston Astros",
    "awayTeamName": "Seattle Mariners",
    "homeTeamRecord": "48-37",
    "awayTeamRecord": "45-40",
    "tvChannel": "ROOT SPORTS NW",
    "venueName": "Daikin Park",
    "venueCity": "Houston",
    "venueState": "TX",
    "sportradarGameId": "8a1b...",
    "recentPerformance": [
        { "date": "2026-06-30", "opponent": "OAK", "value": 2 },
        { "date": "2026-06-29", "opponent": "OAK", "value": 1 }
    ]
}
```

#### Player

| Field | Type | Description |
|-------|------|-------------|
| `playerName` | string | Player's full name |
| `playerTeam` | string | Player's team code/abbreviation |
| `playerPosition` | string | Player's position |
| `playerId` | string | Sleeper player identifier |
| `playerJersey` | string | Jersey number |
| `playerAge` | number | Player age |
| `playerYearsExp` | number | Years of experience |
| `playerStatus` | string | Roster status (Active, etc.) |

#### Line & Odds

| Field | Type | Description |
|-------|------|-------------|
| `league` | string | League the line belongs to |
| `stat` | string | Machine stat/market code |
| `statDisplay` | string | Readable stat label (e.g. "Hits", "3-Pointers Made") |
| `line` | number | Projected line value the over/under is set at |
| `overMultiplier` | number | Payout multiplier for the over |
| `underMultiplier` | number | Payout multiplier for the under |
| `lineType` | string | "normal" or an alternate line type |
| `isAlternate` | boolean | True when this is an alternate projection line |
| `isLive` | boolean | True when the game is in progress |
| `updatedAt` | number | Last update time (epoch milliseconds) |

#### Pick Popularity

| Field | Type | Description |
|-------|------|-------------|
| `pickPopularity` | number | Community popularity score for the line |
| `pickCountOver` | number | Number of community picks on the over |
| `pickCountUnder` | number | Number of community picks on the under |
| `pickCountTotal` | number | Total community picks on the line |

#### Injury & External IDs

| Field | Type | Description |
|-------|------|-------------|
| `playerInjuryStatus` | string | Injury designation (e.g. Questionable, Out); null if healthy |
| `playerInjuryBodyPart` | string | Affected body part, when reported |
| `playerInjuryNotes` | string | Free-text injury note, when reported |
| `playerSportradarId` | string | Sportradar player ID (present for virtually every player) |
| `playerEspnId` | string | ESPN player ID (populated where Sleeper carries it — fullest for NFL; null otherwise) |
| `playerYahooId` | string | Yahoo player ID (populated where Sleeper carries it — fullest for NFL; null otherwise) |
| `playerRotowireId` | string | Rotowire player ID (present for most NFL/NBA/MLB players; null for some leagues) |
| `playerFantasyDataId` | string | FantasyData player ID (populated where Sleeper carries it — fullest for NFL; null otherwise) |

#### Game & Venue

Populated for team sports (MLB, WNBA, CS2, soccer). Individual sports (tennis, golf) carry `gameStart` only.

| Field | Type | Description |
|-------|------|-------------|
| `gameStart` | number | Game start time (epoch milliseconds) |
| `homeTeam` | string | Home team code |
| `awayTeam` | string | Away team code |
| `homeTeamName` | string | Home team full name |
| `awayTeamName` | string | Away team full name |
| `homeTeamRecord` | string | Home team season record |
| `awayTeamRecord` | string | Away team season record |
| `tvChannel` | string | Broadcast channel |
| `venueName` | string | Venue name |
| `venueCity` | string | Venue city |
| `venueState` | string | Venue state |
| `sportradarGameId` | string | Sportradar game ID for cross-referencing |

#### Recent Performance

| Field | Type | Description |
|-------|------|-------------|
| `recentPerformance` | object\[] | The player's recent outings — each entry has `date`, `opponent` (null for some individual sports), and the actual `value` recorded |

### Tips for Best Results

- **Check the league is in-season** — Sleeper's board is a live set that rotates with the calendar. An off-season league returns zero lines, and the run tells you which leagues are active today. Start with "All leagues" to see what's live.
- **Poll periodically before lock** — lines, multipliers, and pick counts move as a slate approaches. Re-run on a schedule to capture the movement rather than a single snapshot.
- **Read pick popularity as a signal** — a lopsided `pickPopularity` with a shortened multiplier is where the public is piling in; the contrarian side is often the better price.
- **Match players across sources with the external IDs** — join on `playerSportradarId` or `playerEspnId` instead of names to avoid duplicate/mismatch headaches with suffixes and nicknames.
- **Use `statDisplay`, not `stat`, for reports** — `statDisplay` is the human-readable label ("Hits", "3-Pointers Made"); `stat` is the raw machine code.
- **Cap broad runs with `maxResults`** — a full "All leagues" board can run into the thousands of lines; set a cap while you're testing, then lift it.
- **Turn on alternate lines only when you need them** — alternates multiply the rows for a player; leave the toggle off for a clean one-line-per-market board.

### Pricing

**From $0.05 per 1,000 results** — flat pay-per-result, one of the lowest rates for live pick'em prop data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.006 | $0.0056 | $0.0053 | $0.005 |
| 1,000 | $0.06 | $0.056 | $0.053 | $0.05 |
| 10,000 | $0.60 | $0.56 | $0.53 | $0.50 |
| 100,000 | $6.00 | $5.60 | $5.30 | $5.00 |

A "result" is one prop line in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate sports data research, model building, and market analysis. Users are responsible for complying with applicable laws, Sleeper's Terms of Service, and all local regulations governing sports wagering. Data is intended for personal research and analytics — do not use it for spam, harassment, or any illegal purpose.

# Actor input Schema

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

Which sports leagues to pull prop lines for. Choose 'All leagues' to grab everything available, or pick specific leagues to keep the run focused. Leave as 'All leagues' if you're unsure.

## `playerNames` (type: `array`):

Optional. Only keep prop lines for these players. Matching is partial and case-insensitive (e.g. 'lebron' matches 'LeBron James'). Leave empty to include all players. You can also paste one line with names separated by commas.

## `statTypes` (type: `array`):

Optional. Only keep these stat markets, e.g. 'Points', 'Rebounds', 'Assists', 'Hits', 'Goals', 'Passing Yards'. Case-insensitive. Leave empty to include every stat type.

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

Optional. Only keep prop lines for these teams. Accepts a team name or abbreviation (e.g. 'Lakers' or 'LAL'), case-insensitive. Leave empty to include all teams.

## `includeAlternateLines` (type: `boolean`):

Turn on to also include alternate projection lines — different target values for the same player and stat, each with its own adjusted payout multipliers. Off by default to keep results to the standard line only.

## `maxResults` (type: `integer`):

Hard cap on how many prop lines to return in one run. Once this many lines have been collected, the run stops adding more. Protects you from an over-broad selection returning thousands of lines. Set to 0 for no limit (returns every matching line).

## Actor input object example

```json
{
  "leagues": [
    "all"
  ],
  "playerNames": [],
  "statTypes": [],
  "teams": [],
  "includeAlternateLines": false,
  "maxResults": 0
}
```

# Actor output Schema

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

Table of prop lines with player, league, stat, projected line, payout multipliers, and community pick popularity.

## `game` (type: `string`):

Table of prop lines with their game matchup, start time, venue, and TV channel.

# 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": [
        "all"
    ],
    "playerNames": [],
    "statTypes": [],
    "teams": [],
    "includeAlternateLines": false,
    "maxResults": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/sleeper-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": ["all"],
    "playerNames": [],
    "statTypes": [],
    "teams": [],
    "includeAlternateLines": False,
    "maxResults": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/sleeper-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": [
    "all"
  ],
  "playerNames": [],
  "statTypes": [],
  "teams": [],
  "includeAlternateLines": false,
  "maxResults": 0
}' |
apify call solidcode/sleeper-player-props-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sleeper Player Props Scraper",
        "description": "[💰 $0.05 / 1K] Extract Sleeper pick'em player prop lines across NBA, NFL, MLB, NHL, soccer, PGA, MMA, tennis, CS2 and more. Get over/under lines, payout multipliers, pick popularity, injury status, game context, and recent performance per line.",
        "version": "1.0",
        "x-build-id": "nHYBgaytTjgJNjbg2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~sleeper-player-props-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-sleeper-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/solidcode~sleeper-player-props-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-sleeper-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/solidcode~sleeper-player-props-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-sleeper-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",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which sports leagues to pull prop lines for. Choose 'All leagues' to grab everything available, or pick specific leagues to keep the run focused. Leave as 'All leagues' if you're unsure.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "nba",
                                "nfl",
                                "mlb",
                                "nhl",
                                "wnba",
                                "pga",
                                "mma",
                                "tennis",
                                "cs",
                                "soccer",
                                "soccer_worldcup"
                            ],
                            "enumTitles": [
                                "All leagues",
                                "NBA (Basketball)",
                                "NFL (Football)",
                                "MLB (Baseball)",
                                "NHL (Hockey)",
                                "WNBA (Basketball)",
                                "PGA (Golf)",
                                "MMA",
                                "Tennis",
                                "CS2 (Esports)",
                                "Soccer (all competitions)",
                                "Soccer - World Cup"
                            ]
                        },
                        "default": [
                            "all"
                        ]
                    },
                    "playerNames": {
                        "title": "Player names",
                        "type": "array",
                        "description": "Optional. Only keep prop lines for these players. Matching is partial and case-insensitive (e.g. 'lebron' matches 'LeBron James'). Leave empty to include all players. You can also paste one line with names separated by commas.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statTypes": {
                        "title": "Stat types",
                        "type": "array",
                        "description": "Optional. Only keep these stat markets, e.g. 'Points', 'Rebounds', 'Assists', 'Hits', 'Goals', 'Passing Yards'. Case-insensitive. Leave empty to include every stat type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "teams": {
                        "title": "Teams",
                        "type": "array",
                        "description": "Optional. Only keep prop lines for these teams. Accepts a team name or abbreviation (e.g. 'Lakers' or 'LAL'), case-insensitive. Leave empty to include all teams.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAlternateLines": {
                        "title": "Include alternate lines",
                        "type": "boolean",
                        "description": "Turn on to also include alternate projection lines — different target values for the same player and stat, each with its own adjusted payout multipliers. Off by default to keep results to the standard line only.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on how many prop lines to return in one run. Once this many lines have been collected, the run stops adding more. Protects you from an over-broad selection returning thousands of lines. Set to 0 for no limit (returns every matching line).",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
