PrizePicks Player Props Scraper

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

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

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

What does PrizePicks Player Props Scraper do?

Each run collects the current public PrizePicks projection board.

It returns one record per matching projection with:

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

The Actor makes one bulk source request per successful run.

It does not make one request per player or projection.

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

Who is it for?

Fantasy analysts

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

Odds and line-comparison products

Normalize PrizePicks projections beside other fantasy or sportsbook sources.

Sports-data teams

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

Alert and history pipelines

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

Automation builders

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

Why use this Actor?

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

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

What PrizePicks data can I extract?

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

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

How to scrape PrizePicks player props

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

The prefilled WNBA input is ready to run.

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

The Actor manages its required Apify proxy automatically.

Input parameters

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

Multiple values inside one filter use OR matching.

Different filter fields combine with AND matching.

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

Input examples

Broad current-board snapshot

{
  "maxItems": 100
}

WNBA points and rebounds

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

Live alert snapshot with raw projection resources

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

Output example

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

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

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

How much does it cost to scrape PrizePicks player props?

The Actor uses pay-per-event pricing:

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

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

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

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

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

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

Tips for reliable recurring snapshots

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

Limits and failure behavior

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

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

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

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

Malformed input fails before source collection.

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

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

Recurring line-history workflow

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

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

Integrations

Google Sheets and CSV

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

Webhooks

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

Make and Zapier

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

Data warehouses

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

Other Apify Actors

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

Run through the Apify API with cURL

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

To wait for completion and receive dataset items directly:

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

Run with JavaScript

import { ApifyClient } from 'apify-client';

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

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

Run with Python

import os
from apify_client import ApifyClient

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

Use through MCP

Add this Actor to Claude Code through Apify MCP:

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

Claude Desktop, Cursor, and VS Code

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

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

Example prompts:

After connecting through MCP, ask your agent:

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

Responsible use and legality

This Actor accesses publicly available projection data without logging in.

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

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

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

The data is informational and can change after collection.

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

Troubleshooting

Why did my run return no records?

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

Why did the source request fail?

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

Why is a field null?

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

Why is allowedWagerTypes empty?

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

Does maxItems reduce proxy traffic?

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

FAQ

Does this Actor require a PrizePicks account?

No. It collects the anonymous public projection board.

Does it require users to configure a proxy?

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

Does it scrape web pages with a browser?

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

Can I filter multiple leagues or players?

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

Can I collect more than 100 records?

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

Can I use this for historical data?

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

Can this Actor place picks or wagers?

No. It only exports public projection data.

Related Actors

• Underdog Fantasy Player Props Scraper — collect comparable current pick'em lines from a separate fantasy source.
• Dataset Dedup — remove duplicate records before downstream export.

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

Support

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

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

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