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

Scrape live PrizePicks player props across NBA, NFL, MLB, NHL, soccer, esports and every active league. Returns line, odds tier (standard/goblin/demon), player, team, matchup, status, and promo flags. HTTP-only, cookieless, MCP-ready.

- **URL**: https://apify.com/khadinakbar/prizepicks-player-props-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 player props

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## PrizePicks Player Props Scraper

Pass a league such as `MLB`, `NBA`, or `NFL` and get **live PrizePicks player props** — line score, odds tier (`standard` / `goblin` / `demon`), player, team, opponent, status, and promo flags. Each dataset row is one public board projection. Designed for DFS research, line monitoring, and AI agents that need structured props without reverse-engineering the board API.

This Actor reads the public PrizePicks partner API over HTTP. It does not log into user accounts and does not return private portfolios.

PrizePicks is a trademark of its respective owner. This independent Actor is not affiliated with, associated with, endorsed by, or sponsored by PrizePicks.

### Best fit for this Actor

- You need a capped snapshot of one or more live PrizePicks boards for modeling or research.
- You want Goblin / Demon tier filters, promo-only rows, or live/in-game status filters in one run.
- You are calling this from Apify API, schedules, or MCP and need flat JSON plus a stable `OUTPUT.outcome`.
- For sportsbook odds outside PrizePicks, continue with the DraftKings sibling Actor linked below.

### MLB slate check for a DFS model

A DFS analyst is refreshing an MLB model before lock. They pass `leagues: ["MLB"]` and `maxResults: 25`. The dataset returns up to 25 projection rows with `playerName`, `statType`, `lineScore`, `oddsType`, and `opponent`. They keep `scrapedAt` as the observation time, then raise `maxResults` only when they need a fuller board.

### Quick start input

```json
{
  "mode": "projections",
  "leagues": ["MLB"],
  "maxResults": 25,
  "singleStat": true
}
```

`maxResults` is the run-wide cost ceiling. Use `mode: "leagues"` first when you only need live league ids.

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `mode` | enum | `projections` (default), `league` (requires leagues or leagueIds), or `leagues` catalog. |
| `leagues` / `leagueIds` | array | Board scope such as `NBA`, `MLB`, or id `7`. Prefill is MLB. |
| `players` / `teams` / `statTypes` | array | Optional case-insensitive substring filters. |
| `oddsTypes` | array | `standard`, `goblin`, and/or `demon`. |
| `promoOnly` / `liveOnly` / `status` | boolean / enum | Promo and live board filters. |
| `maxResults` | integer | Hard cap on billed rows (1–20000). Prefill 25. |

### What data you receive

One dataset item is one player prop (or one league catalog row in `leagues` mode).

```json
{
  "recordType": "player-prop",
  "projectionId": "13957673",
  "playerName": "Shohei Ohtani",
  "team": "LAD",
  "league": "MLB",
  "statType": "Home Runs",
  "lineScore": 1.5,
  "oddsType": "standard",
  "status": "pre_game",
  "isPromo": false,
  "opponent": "SEA",
  "startTime": "2026-09-16T02:10:00.000-04:00",
  "scrapedAt": "2026-09-16T00:00:00.000Z",
  "source": "prizepicks"
}
```

### Real-world use cases

#### 1. MLB capped board snapshot

```json
{
  "mode": "projections",
  "leagues": ["MLB"],
  "maxResults": 25,
  "singleStat": true
}
```

#### 2. Live leagues catalog

```json
{
  "mode": "leagues",
  "maxResults": 10
}
```

#### 3. Goblin-only MLB lines

```json
{
  "mode": "projections",
  "leagues": ["MLB"],
  "oddsTypes": ["goblin"],
  "maxResults": 25
}
```

#### 4. Promo / flash-sale props

```json
{
  "mode": "projections",
  "leagues": ["MLB"],
  "promoOnly": true,
  "maxResults": 25
}
```

#### 5. Two-league research pull

```json
{
  "mode": "projections",
  "leagues": ["MLB", "NBA"],
  "maxResults": 50
}
```

### Why agents choose this Actor

- Flat keys (`playerName`, `statType`, `lineScore`, `oddsType`, `scrapedAt`) instead of nested JSON:API payloads.
- `maxResults` is a hard cost ceiling. Unknown league ids finish as `INVALID_INPUT` instead of a hollow success.
- Terminal `OUTPUT.outcome` values (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`) are stable enough to branch on.
- No PrizePicks login. Public partner-api board data only.

### Agent checklist

1. Pass league names or numeric `leagueIds`. Use `mode: "leagues"` when you need current ids.
2. Set `maxResults` to the number of rows you can bill.
3. After the run, read `OUTPUT.outcome`, then the dataset. Zero rows with `VALID_EMPTY` means the filters matched nothing on the live board.
4. Keep `scrapedAt` and `source` as provenance. Lines move; treat each run as a point-in-time snapshot.
5. Prefer one league and a small cap in agent loops so cost stays forecastable.

### Use through the API

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~prizepicks-player-props-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "projections",
    "leagues": ["MLB"],
    "maxResults": 25,
    "singleStat": true
  }'
```

When the Actor completes, read dataset items from the default dataset and the `OUTPUT` record from the default key-value store.

### Use with AI agents through Apify MCP

> Scrape live MLB PrizePicks player props capped at 25 rows. Return playerName, statType, lineScore, oddsType, opponent, and scrapedAt. Then inspect OUTPUT.outcome before summarizing.

Connect through <https://mcp.apify.com>. After the tool call, read the dataset and the `OUTPUT` / `RUN_SUMMARY` records.

### Pricing

This Actor uses Pay per event plus Apify platform usage. Open the live Pricing tab for current event details, and use Apify's run cost controls to keep the workflow aligned with your budget.

The named result event is `player-prop` (one persisted prop or league-catalog row) plus `apify-actor-start`. Invalid input and fully empty unmatched queries stay unbilled for the named result charge.

### Outcome vocabulary

These values live in the key-value store records `OUTPUT` and `RUN_SUMMARY`, not on each dataset row.

| Outcome | Meaning |
|---|---|
| `COMPLETE` | Requested boards were processed and useful rows were saved without hitting the cap early. |
| `PARTIAL` | Useful rows were saved, but filters, empty boards, or `maxResults` stopped the run short of a full complete board. |
| `VALID_EMPTY` | The request was valid and the live board had no matching props. |
| `INVALID_INPUT` | League mode lacked leagues/ids, or requested league ids could not be resolved. No prop events are charged. |
| `UPSTREAM_FAILED` | The PrizePicks partner API did not return usable board data after the recovery ladder. |

### Connect the workflow

- When you also need sportsbook odds and player props from DraftKings for the same slate, continue with [DraftKings Odds + Player Props](https://apify.com/khadinakbar/scrape-draftkings-odds-player-props) after you finish the PrizePicks board snapshot.
- Prefer this Actor when the job is PrizePicks DFS lines specifically; route non-PrizePicks sportsbook work to the DraftKings sibling instead of stretching this contract.

### Best results

- Start with one league and a small `maxResults` while testing.
- Use `mode: "leagues"` to discover live ids before a multi-league pull.
- Empty boards or filters with no matches finish as truthful `VALID_EMPTY` (no hollow rows).
- Set an explicit `maxResults` on busy slates so billed volume stays predictable.

### Builder's note

I built this after confirming that `api.prizepicks.com` is DataDome-walled from datacenter and many residential exits, while `partner-api.prizepicks.com` serves the same `/leagues` and `/projections` JSON:API without a login. In my testing, inventing targets for unknown league ids produced misleading scrapes, so unresolved ids now finish as `INVALID_INPUT`. I also removed a silent schema default for `leagues` so empty league mode stays an explicit validation path rather than quietly injecting MLB.

### FAQ

**Do I need a PrizePicks account?**
No. The Actor reads the public partner API board data.

**What are Goblin and Demon?**
PrizePicks odds tiers: Goblin is typically an easier line with lower payout; Demon is a harder line with higher payout. Standard is the normal board line.

**Can an AI agent use this?**
Yes. Pass leagues or filters, then read one row per prop and inspect `OUTPUT.outcome`.

**Why did I get INVALID\_INPUT?**
`mode: "league"` requires leagues or leagueIds, and numeric ids must exist in the live catalog.

### Responsible use

This Actor returns publicly exposed PrizePicks board projections for research, modeling, and automation you are authorized to run. Treat outputs as point-in-time board snapshots, keep request volume courteous, and comply with PrizePicks terms, local gambling laws, and your own data-use policies. Stay within public board data and authorized research workflows; account login and age or geo circumvention are outside this Actor's contract.

PrizePicks is a trademark of its respective owner. This independent Actor is not affiliated with, associated with, endorsed by, or sponsored by PrizePicks.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. projections = player props across selected leagues (default). league = same as projections but requires an explicit league. leagues = output the live league catalog only (ids, names, projection counts).

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

League names to scrape. Use All for every active board with projections. Names are matched against the live PrizePicks catalog (case-insensitive). Leave empty in projections mode to scrape all active leagues. Type custom seasonal names via leagueIds or free-text known aliases like NBA/MLB.

## `leagueIds` (type: `array`):

Optional numeric PrizePicks league ids (for example 7 for NBA, 9 for NFL, 2 for MLB). Combined with leagues. Use mode=leagues first if you need current ids.

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

Optional case-insensitive substring filters on player display name. Example: Ohtani, Jokic. Leave empty for all players.

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

Optional case-insensitive filters matching the player team or opponent description. Example: LAL, Yankees, SEA.

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

Optional case-insensitive substring filters on stat type. Example: Points, Strikeouts, Passing Yards, PRA.

## `oddsTypes` (type: `array`):

Keep only these PrizePicks odds tiers. standard = normal line, goblin = easier lower payout, demon = harder higher payout. Leave empty for all tiers.

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

Keep only projections in this state. Leave empty for all statuses.

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

When true, keep only promotional or flash-sale projections.

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

When true, request in-game projections and keep status=in\_progress rows.

## `singleStat` (type: `boolean`):

When true (default), request PrizePicks single-stat projections. Turn off only if you intentionally want non-single-stat board modes.

## `gameMode` (type: `string`):

PrizePicks game\_mode query value. pickem is the default consumer board.

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

Optional two-letter state code for geo-filtered lines (example: CA, NY). Leave empty for the default board.

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

Hard cap on dataset rows written and billed. Prefill is intentionally small for cheap quality tests. Raise for full-board snapshots (busy days can exceed 5,000+ props).

## `perPage` (type: `integer`):

PrizePicks JSON:API page size (1-1000). Larger pages mean fewer requests.

## `includeLeagueCatalog` (type: `boolean`):

Reserved for diagnostics. Prefer mode=leagues when you only need the catalog as dataset rows.

## Actor input object example

```json
{
  "mode": "projections",
  "leagues": [
    "MLB"
  ],
  "promoOnly": false,
  "liveOnly": false,
  "singleStat": true,
  "gameMode": "pickem",
  "maxResults": 25,
  "perPage": 250,
  "includeLeagueCatalog": false
}
```

# Actor output Schema

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

Dataset items containing player props (line, odds type, promo, game) and optional league catalog rows.

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

Run summary including outcome, itemsPushed, league targets, warnings, and billing counters.

## `runSummary` (type: `string`):

Machine-readable RUN\_SUMMARY record mirroring OUTPUT for integrations that read RUN\_SUMMARY directly.

# 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 = {
    "mode": "projections",
    "leagues": [
        "MLB"
    ],
    "gameMode": "pickem",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "mode": "projections",
    "leagues": ["MLB"],
    "gameMode": "pickem",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/prizepicks-player-props-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 '{
  "mode": "projections",
  "leagues": [
    "MLB"
  ],
  "gameMode": "pickem",
  "maxResults": 25
}' |
apify call khadinakbar/prizepicks-player-props-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/prizepicks-player-props-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/L9ttBud5PcccrpAOI/builds/ytfkqNDZcxe2qLB2O/openapi.json