# PrizePicks Scraper - Player Props, Lines, Goblins & Demons (`topapi/prizepicks-scraper`) Actor

Scrape every PrizePicks player prop: line, standard / goblin / demon tier, standard line and ladder, player, team, opponent, game time, league, trending count. All leagues or the ones you pick, player / team / stat filters, monitor mode for line moves. $0.09 per 1,000 props.

- **URL**: https://apify.com/topapi/prizepicks-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.09 / 1,000 props

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does PrizePicks Scraper do?

**PrizePicks Scraper** extracts the player props on [PrizePicks](https://app.prizepicks.com) and turns the board into structured rows: one row per prop (PrizePicks calls it a projection) with the **line**, the **odds tier** (standard, goblin or demon), the **standard line** the goblins and demons are built around, the player, team, opponent, game time, league and PrizePicks' own timestamps. Take every league in one run or only the ones you name, filter by player, team, stat or tier, and run it on a schedule in monitor mode to get only the props that are new, moved or taken off the board. Built for DFS players, prop-model builders, line-shopping tools, Discord and Telegram bots, and picks newsletters.

PrizePicks Scraper · PrizePicks API alternative · PrizePicks props scraper · PrizePicks projections · goblin and demon lines

- **The whole board in one run:** every league PrizePicks lists, 42,640 props across 29 leagues in the measured run of 2026-11-06, or one league, a few leagues, or their first-half, quarter and period boards
- **The ladder on every row:** `standard_line`, `line_vs_standard` and `alternate_lines_count` tell you how far each goblin or demon sits from the standard line; switch on the full ladder (`alternate_lines`) when you want every rung on every row
- **Monitor mode for line moves:** a scheduled run returns only new props, props whose line, tier, sides, status or start time changed (with `previous_line`, `line_move`, `move_count`), and optionally props PrizePicks took off the board
- **90 fields per prop:** player, team colors and logos, home and away teams, matchup, opponent, period, trending count and rank, board time, last update, stable ids for prop, player, game, league and teams
- **No login, cookies or PrizePicks API key:** it reads the JSON board PrizePicks serves to its partners
- **Pay only for delivered props:** no start fee; props your filters remove and unchanged props in monitor mode cost nothing
- **Export anywhere:** JSON, CSV, Excel, XML, RSS; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Slack
- **Works with AI agents:** call it through the Apify API or the MCP server

### What data can you get from PrizePicks?

<table>
<tr><td>🎯 Line (`line`)</td><td>😈 Odds tier: standard, goblin, demon (`odds_tier`)</td><td>📏 Standard line and the distance to it</td></tr>
<tr><td>📊 Stat, long and short (`stat`, `stat_short`)</td><td>⏱️ Period: full game, half, quarter, map (`duration`)</td><td>↕️ Over only or over and under (`allowed_wager_types`)</td></tr>
<tr><td>👤 Player, position, jersey, headshot</td><td>👥 Combo lines of two players (`player_combo`)</td><td>🏟️ Player's team, name, market, logo, color</td></tr>
<tr><td>🆚 Home and away team, matchup, opponent</td><td>🏠 Home or away (`is_home`)</td><td>🎨 Team colors and logos</td></tr>
<tr><td>📅 Start time, hours to start</td><td>🕒 Board time and last update</td><td>🔴 Status, live and in-game flags</td></tr>
<tr><td>🔥 Trending count and rank in the league</td><td>🏷️ Promo flag, flash-sale line</td><td>🏆 League, sport, parent league of a period board</td></tr>
<tr><td>🆔 Prop, player, game, league and team ids</td><td>🔗 Link to the prop in the PrizePicks app</td><td>📈 Monitor: previous line, line move, move count</td></tr>
</table>

On the whole-board run of 2026-11-06 (42,640 props) every row had the line, tier, stat, player, team, position, league, period, start time, board time and last update; 99% had the game, both teams and the matchup, 96% the opponent, 94% said whether the line is over-only, 48% had a standard line to compare with (the rest are ladders PrizePicks lists without a standard rung) and 8% a trending count. The tiers were 27,068 demon, 9,800 goblin and 5,772 standard lines.

### How to scrape PrizePicks with PrizePicks Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up): $5 of monthly credit, no card needed.
2. Open [PrizePicks Scraper](https://apify.com/TopApi/prizepicks-scraper) and click **Try for free**.
3. Pick **Leagues** (or keep **All**) and set **Max results** (0 = the whole board).
4. Add filters if you want: players, teams, stats, odds tiers, start window.
5. Click **Start**. A league's board arrives in a few seconds.
6. Open the **Storage** tab and **Export** as JSON, CSV or Excel, or let a schedule run it for you in monitor mode.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to read** | | |
| `leagues` | List | League names as PrizePicks writes them (`NBA`, `NFL`, `CFB`, `SOCCER`, `EPL`, `TENNIS`, `CS2`, `NBA1Q` ...) or league ids. `All` = every league. `Esports` = the esports leagues. Default: `All` |
| `extraLeagues` | Text | More names or ids, comma-separated, for seasonal boards (`WORLD CUP, LIVGOLF`) |
| `includePeriodBoards` | Boolean | The named leagues bring their first-half, quarter and period boards too (NBA -> NBA1Q, NBA1H, NBA2H, NBA4Q). Default `false` |
| `listLeagues` | Boolean | Return one row per league with props right now (props count, id, parent league), then stop |
| `maxResults` | Integer | Most rows per run. Default `1000`; `0` = no limit |
| `maxResultsPerLeague` | Integer | Most rows from one league. `0` = no limit |
| **🎯 Filters** (before the charge) | | |
| `playerNames` | List | Part of a name, any case, accents ignored (`Jokic` finds Nikola Jokić) |
| `teams` | List | Team name or abbreviation; matches the player's team or either side of the game |
| `statTypes` | List | Long or short stat name (`Points`, `PRA`, `Pass Yards`); exact match, or part of the name when no line carries it exactly |
| `oddsTiers` | List | `standard`, `goblin`, `demon` |
| `status` | Select | `pre_game`, `in_progress`, `final` |
| `liveOnly` / `excludeLive` | Boolean | Only, or no, lines of games in progress |
| `promoOnly` | Boolean | Only promo and flash-sale lines |
| `excludeCombos` | Boolean | Drop lines that add up two or more players |
| `onlyBothSides` | Boolean | Only lines PrizePicks offers over and under |
| `startsWithinHours` | Integer | Only games starting within this many hours |
| `projectionIds` | List | Track exact props: ids (`16738162`) or `projection_url` links from earlier runs. Up to 300 ids are asked from PrizePicks by id (one small request per 150 ids, 1-1.7 s per run); rows read this way carry `standard_line` only when the standard line of the ladder is among the ids, and no `alternate_lines_count` or `trending_rank` |
| `keywords` / `keywordMatch` / `excludeKeywords` | List / Select / List | Keep or drop lines whose player, team, description, stat, league, position or period contains the words (any or all) |
| `stateCode` | Text | Two-letter US state sent as PrizePicks' `state_code` |
| **📦 Output** | | |
| `includeAlternateLines` | Boolean | Every row gets `alternate_lines` (id, line, tier of every other rung). Default `false` |
| `sortBy` | Select | `board` (PrizePicks' order), `startTime`, `trending`, `league` |
| **🔁 Monitor mode** | | |
| `monitorMode` | Boolean | Return only props that are new or changed since the last run of the same input |
| `onlyLineMoves` | Boolean | A known prop comes back only when its line moved |
| `minLineMove` | Number | Only moves at least this big; smaller moves add up across polls |
| `includeRemoved` | Boolean | Props taken off the board come back once as `change_type: "removed"` |
| `firstRunMode` | Select | `emitAll` (first run returns the board) or `seedOnly` (first run only remembers it, nothing charged) |
| `monitorStoreName` / `resetMonitor` | Text / Boolean | Name of the memory; start it over |
| **⚙️ Advanced** | | |
| `proxyConfiguration` | Proxy | Not needed (see Limits); a proxy you set here is tried first |

The input names of other PrizePicks actors work too (`players`, `stats`, `oddsTypes`, `maxItems`, `leagueIds`, `mode: "leagues"`, `includeLiveOnly`, `excludeLiveLines`, `monitoringMode`, `resetMonitoringState`), so an API caller can switch without rewriting its input.

#### Input JSON

```json
{
  "leagues": ["NBA", "NHL"],
  "statTypes": ["Points", "PRA", "Shots On Goal"],
  "oddsTiers": ["standard", "goblin"],
  "maxResults": 0
}
```

#### Name two leagues or fewer for the fastest run

One or two leagues are read one board at a time (NBA: 343 KB, 7,700 props, 8.6 s for the whole run). Three or more leagues, `All`, or a name the actor does not know yet read the whole board once (2.2 MB, 42,000 props) and keep your leagues. **Do:** `"leagues": ["NBA"]` · **Don't:** `"leagues": ["NBA", "NBA1Q", "NBA1H", "NBA2H"]` when you only want full-game props.

#### Period boards are separate leagues

PrizePicks lists first-half, quarter and period props as their own boards (`NFL1H`, `NFL1Q`, `NBA1Q`, `NHL1P`, `CFB1H`). Name them, or switch on `includePeriodBoards`. `NFL` alone is full-game props only.

#### Use monitor mode instead of reading the board every few minutes

A monitored NBA board polled 2.5 minutes apart returned 97 rows (29 new props, 41 changed, 27 taken off) instead of 7,698. A poll with nothing new costs nothing.

### ⬆️ Output

Every prop becomes one dataset item. A real row from `{"leagues": ["NBA"], "playerNames": ["LeBron"]}` (2026-11-06, shortened: the 20 home and away team fields are cut here):

```json
{
  "record_type": "projection",
  "projection_id": "16729423",
  "line": 29.5,
  "stat": "Pts+Rebs+Asts",
  "stat_short": "PRA",
  "odds_tier": "goblin",
  "standard_line": 30.5,
  "line_vs_standard": -1,
  "alternate_lines_count": 6,
  "status": "pre_game",
  "start_time": "2026-11-06T19:30:00.000-05:00",
  "board_time": "2026-11-05T21:02:15.790-05:00",
  "updated_at": "2026-11-06T17:17:36.075-05:00",
  "allowed_wager_types": "under_or_over",
  "over_only": false,
  "trending_count": 295,
  "player_name": "LeBron James",
  "player_team": "PHI",
  "player_position": "F",
  "player_id": "336267",
  "league": "NBA",
  "league_id": 7,
  "matchup": "PHI @ CLE",
  "opponent": "CLE",
  "is_home": false,
  "duration": "Full",
  "hours_to_start": 2.2,
  "projection_url": "https://app.prizepicks.com/?projection=16729423"
}
```

In monitor mode a changed prop carries what changed (real row, NBA board, 2026-11-06):

```json
{
  "projection_id": "16738153",
  "player_name": "Jayson Tatum",
  "stat_short": "Points",
  "line": 28.5,
  "odds_tier": "demon",
  "change_type": "changed",
  "change_kinds": ["line", "sides"],
  "previous_line": 27.5,
  "line_move": 1,
  "first_seen_line": 27.5,
  "line_move_since_first_seen": 1,
  "move_count": 1,
  "previous_allowed_wager_types": "under_or_over",
  "allowed_wager_types": "over",
  "previously_seen_at": "2026-11-06T21:29:00.000Z"
}
```

With **List available leagues** one row per league (29 rows on 2026-11-06):

```json
{
  "record_type": "league",
  "league": "CFB",
  "availableProps": 7788,
  "league_id": 15,
  "active": true,
  "icon": "football",
  "parent_id": null,
  "has_live_projections": false,
  "show_trending": true,
  "f2p_enabled": true
}
```

#### Fields

Fill measured on the whole-board run of 2026-11-06 (42,640 props, 29 leagues).

| Field | Type | What it is | Fill |
|---|---|---|---|
| `projection_id` | string | PrizePicks prop id; stays the same when the line moves | 100% |
| `line` | number | The line | 100% |
| `stat`, `stat_short` | string | Stat, long and short name | 100% |
| `odds_tier` | string | `standard`, `goblin` or `demon` | 100% |
| `standard_line`, `line_vs_standard` | number | Standard line of the same player, stat, game and period, and the distance to it | 47.6% |
| `alternate_lines_count` | integer | Other lines on the same player, stat, game and period | 100% |
| `alternate_lines` | array | With `includeAlternateLines`: the other rungs (id, line, tier) | on |
| `allowed_wager_types`, `over_only` | string, boolean | `over` or `under_or_over` | 93.9% |
| `status`, `is_live`, `in_game`, `is_live_scored` | string, boolean | Line state and live flags | 100% |
| `start_time`, `board_time`, `updated_at` | ISO 8601 | Start, posted, last changed | 100% |
| `hours_to_start` | number | Hours from the run to the start | 100% |
| `description` | string | PrizePicks' own text: usually the opponent, the season for season props, the map for esports | 100% |
| `event_type`, `projection_type`, `rank`, `group_key` | string, integer | Event type, Single Stat or Fantasy Score, board position, ladder key | 100% |
| `adjusted_odds`, `is_promo`, `refundable` | boolean | PrizePicks flags | 99-100% |
| `trending_count`, `trending_rank` | integer | Picks on the line and its rank in the league | 8.3% |
| `today` | boolean | PrizePicks' today flag (sent only when true) | 33.2% |
| `player_name`, `player_full_name`, `player_id`, `player_position`, `player_combo`, `player_league`, `player_league_id`, `player_team`, `player_team_id` | string, integer, boolean | The player (or combo) | 100% |
| `player_team_name`, `player_market`, `player_jersey`, `player_ppid`, `player_image` | string | Team name, market, jersey, code, headshot | 96.7-99.8% |
| `player_team_color`, `player_team_logo` | string | The player's team color and logo | 90.9%, 56.9% |
| `league`, `league_id`, `sport`, `league_ppid` | string, integer | League and sport | 100% |
| `league_parent_id`, `league_parent_name` | integer, string | Full-game league of a period board | 11.7% (period boards) |
| `game_id`, `game_external_id`, `game_record_external_id`, `game_start`, `game_status`, `game_is_live`, `game_created_at`, `game_updated_at` | string, boolean | The game | 99.9% |
| `home_team`, `away_team`, `*_team_name`, `*_team_market`, `*_team_id`, `*_team_ppid`, `*_team_color`, `matchup` | string | Both teams | 98.3-98.8% |
| `*_team_secondary_color`, `*_team_tertiary_color` | string | Team colors | 89.0-96.0% |
| `home_team_logo`, `away_team_logo` | string | Team logos | 69.2% |
| `opponent`, `is_home` | string, boolean | The other team, home or away | 96.2% |
| `duration`, `projection_type_name`, `stat_type_id`, `stat_rank`, `stat_lfg_ignored_leagues` | string, integer, array | Period and stat records | 100% (the last one 14.3%) |
| `tv_channel` | string | TV channel, when PrizePicks sets one | 0% that day |
| `flash_line`, `custom_image`, `end_time`, `game_end`, `discount_name`, `discount_percentage`, `hot` | | Present only on lines PrizePicks sets them on (flash sales, custom cards, ended games, discounts); none of the 42,640 lines carried them that day | 0% that day |
| `projection_url`, `source`, `scraped_at`, `record_type` | string | Link to the prop, source, run time | 100% |
| `change_type`, `change_kinds`, `previous_line`, `line_move`, `first_seen_line`, `line_move_since_first_seen`, `move_count`, `previous_odds_tier`, `previous_allowed_wager_types`, `previous_status`, `previous_start_time`, `first_seen_at`, `previously_seen_at`, `removed_at` | | Monitor mode only | |

### How can I use PrizePicks data?

- 🎯 **DFS players and prop bettors:** take today's goblins with the biggest gap to the standard line (`line_vs_standard`), or only lines that offer both sides
- 📊 **Prop-model builders:** feed every line with `projection_id`, `player_id`, `game_id` and `stat_type_id` into your projections and keep a line history with monitor mode
- 🔎 **Line-shopping tools:** compare PrizePicks lines with sportsbook or other pick'em lines for the same player and stat; `projection_id` stays the same when a line moves
- 🤖 **Discord and Telegram bots:** a 5-minute monitor schedule with `onlyLineMoves` and `minLineMove: 1` posts only the real moves
- 📨 **Picks newsletters and content:** sort by `trending` to get the most-picked lines of each league
- 📈 **Analysts:** count lines by league, stat and tier, or measure how often and how far PrizePicks moves a line before the game

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

PrizePicks Scraper is pay-per-event, with no start fee:

| Row | Price |
|---|---:|
| Prop (`projection`) | **$0.09 per 1,000** |
| League row (`league`, List available leagues) | $0.18 per 1,000 |

| Run (measured 2026-11-06) | Props | Cost |
|---|---:|---:|
| One player on the NBA board | 81 | $0.0073 |
| UFC board | 113 | $0.010 |
| Default input (`All`, 1,000 props) | 1,000 | $0.09 |
| NBA board | 7,437 | $0.67 |
| NBA + NHL boards | 9,564 | $0.86 |
| Every league, whole board | 42,640 | $3.84 |
| Monitor poll of the NBA board, 2.5 minutes after the last | 97 | $0.0087 |
| Monitor poll with nothing new | 0 | $0 |
| Three prop ids | 3 | $0.00027 |

The ladder, standard line, trending rank and monitor fields cost nothing extra. Props your filters remove, unchanged props in monitor mode and empty runs are never charged. Apify platform usage is included.

### Run it on a schedule

- **Schedules:** save your input as a task, open **Schedules** and run it every few minutes on game days. With `monitorMode: true` each run returns only props that are new or changed since the last run of the same input; a poll that finds nothing writes nothing and charges nothing.
- **Example:** `{"leagues": ["NFL", "NFL1H"], "monitorMode": true, "onlyLineMoves": true, "minLineMove": 1, "includeRemoved": true, "monitorStoreName": "nfl-moves"}` every 5 minutes.
- **Webhooks:** fire a URL when a run finishes and push the rows to a bot, a sheet or your database.
- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable, Slack through [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client`; code is on the [API tab](https://apify.com/TopApi/prizepicks-scraper/api/python) and in the [Apify API reference](https://docs.apify.com/api/v2).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/TopApi/prizepicks-scraper/api/mcp) and ask for PrizePicks props in plain language.

### More sports and odds scrapers

<table>
<tr>
<td>📈 <a href="https://apify.com/ScrapersDelight/sports-odds-scraper">Live Odds Scraper: NFL, NBA, MLB</a></td>
<td>🎾 <a href="https://apify.com/ScrapersDelight/sofascore-tennis-scraper">SofaScore Tennis Scraper</a></td>
<td>🎾 <a href="https://apify.com/ScrapersDelight/flashscore-tennis-scraper">Flashscore Tennis Scraper</a></td>
</tr>
<tr>
<td>🔮 <a href="https://apify.com/ScrapersDelight/kalshi-markets-scraper">Kalshi Prediction Markets Scraper</a></td>
<td>🔮 <a href="https://apify.com/ScrapersDelight/limitless-markets-scraper">Limitless Prediction Market Scraper</a></td>
<td>🧭 <a href="https://apify.com/TopApi">All TopApi actors</a></td>
</tr>
</table>

### Limits & empty runs

- **What PrizePicks lists right now:** the board is live, so a run returns the lines listed at that moment and an off-season league is empty. On 2026-11-06 every NBA, NFL and CFB line read was pre-game; in-progress lines were on the tennis board (14 of 126).
- **Board size:** 42,640 props in 29 leagues on 2026-11-06 (CFB 7,787, NBA 7,699, NFL 7,233, SOCCER 5,176, EPL 2,545, MLS 1,812, NHL 1,790, NFL1H 1,623, NFL1Q 1,450, CBB 1,232, ...).
- **Speed:** a league's board in 1-10 s; the whole board in 2-2.5 minutes (most of it is writing 42,000 rows). Memory is fixed at 256 MB: the whole board peaks at 143 MB, and more memory does not make a run faster.
- **Requests:** PrizePicks answers about two requests in a short burst per address and then refuses that address for about a minute. A run makes one or two requests; when an address is refused the run moves to Apify's US datacenter proxy, and only when every address is busy does it wait the minute out (it says so in the log).
- **Location:** PrizePicks answers addresses outside the US with "PrizePicks is currently unavailable in your location"; the run uses US exits, and Apify's US residential proxy only when the props it will bill pay for the transfer.
- **State:** `stateCode` is passed to PrizePicks as `state_code`; on 2026-11-06 the board came back the same with and without it (CA, NY).
- **Empty dataset:** the status message names the cause: no props on that board right now, a league name PrizePicks does not have, filters that removed every line (with the count per filter), or a monitor poll with nothing new. Nothing is charged.
- **Not available:** payouts and prices (PrizePicks shows tiers, not odds), results and scores, user picks and entries.

### FAQ

#### How many props can PrizePicks Scraper collect in one run?

The whole board: 42,640 props across 29 leagues in one run on 2026-11-06. Set `maxResults` to `0` for everything, or cap it.

#### What are goblin and demon lines?

Alternate lines on the same player and stat. A goblin is set below the standard line and is easier to hit for a lower payout; a demon is set above it and is harder for a higher payout. Every row carries the `standard_line` of its ladder and `line_vs_standard`; a goblin 29.5 on a 30.5 standard reads `-1`.

#### Can PrizePicks Scraper track line movement?

Yes. Monitor mode remembers each prop it returned (per input) and returns it again only when its line, tier, sides, status, flash line or start time changes, with `previous_line`, `line_move`, `first_seen_line` and `move_count`. `includeRemoved` adds props PrizePicks took off the board.

#### Can I get first-half, quarter and period props?

Yes. They are separate PrizePicks boards (`NBA1Q`, `NBA1H`, `NFL1H`, `NFL1Q`, `NHL1P`, `CFB1H`); name them or switch on `includePeriodBoards`.

#### Can I see which leagues are live right now?

Run with `listLeagues: true`: one row per league with props on the board, its id and the number of props.

#### Can I use PrizePicks Scraper with the Apify API or MCP?

Yes. Start runs and read datasets with `apify-client` from the API tab, or connect an MCP client through the MCP tab.

#### Do I need a PrizePicks account, cookies or an API key?

No. PrizePicks Scraper reads the board PrizePicks serves without a login.

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

The status message says why: the board of that league is empty right now, PrizePicks has no league by that name (run `listLeagues`), your filters removed every line (it lists how many each filter removed), or a monitor poll found nothing new.

#### Is this betting advice?

No. It returns the lines PrizePicks publishes and nothing more.

#### Is it legal to scrape PrizePicks?

PrizePicks Scraper reads only publicly available board data and does not log in. Make sure your use complies with PrizePicks' terms and the rules where you are.

#### How is PrizePicks Scraper different from other PrizePicks scrapers?

It reads every league in one request, puts the standard line and the ladder size on every goblin and demon row, has a monitor mode that reports line moves and removed props, keeps every rival's filters and input names, and has no start fee: $0.09 per 1,000 props.

#### Your feedback

Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/TopApi/prizepicks-scraper/issues/open).

# Actor input Schema

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

Leagues as PrizePicks names them (NBA, NFL, CFB, SOCCER, EPL, TENNIS, CS2, NBA1Q ...) or league ids. <code>All</code> = every league on the board. Pick from the list or type any league; run with <b>List available leagues</b> to see what is live now.

## `extraLeagues` (type: `string`):

More league names or ids, comma-separated (for seasonal boards not in the list, e.g. <code>WORLD CUP, LIVGOLF</code>). Added to Leagues.

## `includePeriodBoards` (type: `boolean`):

PrizePicks lists 1st-half, quarter and period lines as separate boards (NFL1H, NBA1Q, NHL1P ...). On: the named leagues bring their period boards too.

## `listLeagues` (type: `boolean`):

Return one row per league that has props right now (name, id, props on the board, parent league, live flag), then stop. Other inputs except Leagues are ignored.

## `includeInactiveLeagues` (type: `boolean`):

With List available leagues: also list the catalog's leagues that have no board right now.

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

Most rows this run returns and charges for. 0 = no limit (the whole board of every league was 41,799 lines on 2026-11-06; one league holds 100 to 7,700).

## `maxResultsPerLeague` (type: `integer`):

Most rows from any one league. 0 = no limit.

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

Keep only these players: part of a name, any case, accents ignored (<code>Jokic</code> finds Nikola Jokić).

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

Team names or abbreviations (<code>Lakers</code>, <code>LAL</code>, <code>Chiefs</code>). Matches the player's team or either side of the game.

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

Stats by their long or short name (<code>Points</code>, <code>PRA</code>, <code>Pass Yards</code>, <code>Shots On Goal</code>). Exact match; a name no line carries exactly matches as part of the stat name.

## `oddsTiers` (type: `array`):

Standard = the main line; goblin = an easier line that pays less; demon = a harder line that pays more. Empty = all three.

## `status` (type: `string`):

Keep only lines in this state. Empty = all.

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

Keep only lines of games already in progress.

## `excludeLive` (type: `boolean`):

Drop lines of games already in progress.

## `promoOnly` (type: `boolean`):

Keep only lines PrizePicks marks as a promo or flash sale.

## `excludeCombos` (type: `boolean`):

Drop lines that add up two or more players (e.g. 'Cooper Flagg + Lauri Markkanen').

## `onlyBothSides` (type: `boolean`):

Keep only lines PrizePicks offers both ways (under_or_over); over-only lines are dropped.

## `startsWithinHours` (type: `integer`):

Keep only lines whose game starts within this many hours from now. 0 = no limit.

## `projectionIds` (type: `array`):

Track exact props: PrizePicks prop ids (<code>16738162</code>) or the <code>projection_url</code> of a row from an earlier run. Up to 300 ids are asked from PrizePicks by id; their rows carry no ladder count or trending rank.

## `keywords` (type: `array`):

Keep a line if one (Any) or all (All) of these appear in its player, team, description, stat, league, position, period or teams.

## `keywordMatch` (type: `string`):

Any = at least one keyword; All = every keyword.

## `excludeKeywords` (type: `array`):

Drop a line if any of these appear in the same fields.

## `stateCode` (type: `string`):

Two-letter US state sent to PrizePicks as state_code (e.g. CA, NY). On 2026-11-06 the board came back the same with and without it.

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

Every row gets alternate_lines: the other lines PrizePicks offers on the same player, stat, game and period (id, line, tier). standard_line and alternate_lines_count are always there.

## `sortBy` (type: `string`):

Board = PrizePicks' own order per league; start time = earliest game first; trending = most-picked first; league = by league name.

## `monitorMode` (type: `boolean`):

On: the run remembers the lines it returned (per input) and later runs return only props that are new or whose line, tier, sides, status, flash line or start time changed, with previous_line and line_move. Schedule it.

## `onlyLineMoves` (type: `boolean`):

Monitor mode: return a known prop only when its line itself moved (not for a tier, sides, status or start-time change).

## `minLineMove` (type: `number`):

Monitor mode: return a known prop only when its line moved at least this far since it was last returned. 0 = any move. Smaller moves add up across polls.

## `includeRemoved` (type: `boolean`):

Monitor mode: a remembered prop no longer on its league's board comes back once as change_type 'removed' (last line, tier, player, stat), then is forgotten.

## `firstRunMode` (type: `string`):

Return all: the first run returns the board and remembers it. Seed only: the first run only remembers the board (nothing charged) and later runs return changes.

## `monitorStoreName` (type: `string`):

Name of the memory (one named dataset per name and input). Use different names for separate schedules of the same input.

## `resetMonitor` (type: `boolean`):

Forget what this input's memory holds before the run, so every line counts as new again.

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

Not needed: the run starts on a direct connection and moves up to Apify's datacenter and then US residential proxy on its own when PrizePicks refuses an address. Set your own proxy here to use it first.

## Actor input object example

```json
{
  "leagues": [
    "All"
  ],
  "includePeriodBoards": false,
  "listLeagues": false,
  "includeInactiveLeagues": false,
  "maxResults": 1000,
  "maxResultsPerLeague": 0,
  "status": "",
  "liveOnly": false,
  "excludeLive": false,
  "promoOnly": false,
  "excludeCombos": false,
  "onlyBothSides": false,
  "startsWithinHours": 0,
  "keywordMatch": "any",
  "includeAlternateLines": false,
  "sortBy": "board",
  "monitorMode": false,
  "onlyLineMoves": false,
  "minLineMove": 0,
  "includeRemoved": false,
  "firstRunMode": "emitAll",
  "monitorStoreName": "prizepicks-monitor",
  "resetMonitor": false
}
```

# Actor output Schema

## `results` (type: `string`):

One item per PrizePicks prop (projection): line, odds tier, standard line, player, team, game, league, timestamps; in monitor mode only new, changed or removed props. League rows with List available leagues.

## `summary` (type: `string`):

Boards read (egress, bytes, lines read and delivered), per-league counts, filters, monitor memory (written for Console runs, large runs and runs with a problem).

# 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"
    ],
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/prizepicks-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"],
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/prizepicks-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "leagues": [
    "All"
  ],
  "maxResults": 1000
}' |
apify call topapi/prizepicks-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/prizepicks-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RLe7wiLUMGxtgcS4e/builds/8M4vfkN3dEh2SElNU/openapi.json
