# Underdog Fantasy Player Props (`automatic/underdog-player-props`) Actor

Collect Underdog pick’em player props with paired higher/lower sides, lines, native payout details and saved change tracking. Filter supported leagues, players, teams, stats and UTC game dates.

- **URL**: https://apify.com/automatic/underdog-player-props.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Sports
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 1,000 player 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

## Underdog Fantasy Player Props

Collect Underdog Fantasy pick'em player lines for DFS research, with Higher and Lower selections together in each prop row. Get native player and game IDs, game times, stat labels, lines, side availability and payout details. Save a baseline to monitor changes across scheduled runs.

### Use cases

- Compare DFS lines across pick'em providers using consistent player, stat and game fields.
- Compare a prop with sportsbook lines after checking the player, event, period and settlement rules.
- Supply current line and availability observations to a model without mistaking fantasy multipliers for betting odds.
- Build alerts for new props, line moves, payout changes, suspended selections and removals.

### Also available

The player props suite: pick the job.

| Actor | Use when |
|---|---|
| **Underdog Props (this Actor)** | Underdog higher/lower lines and payouts |
| [PrizePicks Props](https://apify.com/automatic/prizepicks-player-props) | PrizePicks lines and projection changes |
| [Sleeper Picks Props](https://apify.com/automatic/sleeper-player-props) | Sleeper lines, multipliers and changes |
| [DraftKings Pick6](https://apify.com/automatic/pick6-player-props) | Pick6 props, multipliers and alternates |
| [BetRivers Odds & Props](https://apify.com/automatic/betrivers-odds-player-props) | BetRivers and Unibet lines plus player props |
| [Sports Injury Reports](https://apify.com/automatic/sports-injuries) | Injury status changes across leagues |

### Quick start

The Console prefill requests up to 20 NBA/NFL props:

```json
{"leagues":["nba","nfl"],"includeAlternates":false,"includeLive":false,"maxResults":20,"onlyChangesSinceLastRun":false,"proxyConfiguration":{"useApifyProxy":false},"allowPartial":false}
```

Running `{}` announces “Sample run (...)”, returns at most 20 props across supported leagues and sets `OUTPUT.sampleRun: true`. During a dead period it succeeds with an honest empty summary. An explicitly empty filter, such as `leagues: []`, ends the run as `no_results` and names the field. Omit filters to include everything supported. Lists accept at most 200 distinct values of at most 200 characters each. Empty, whitespace-only, duplicate normalized values and values without Latin letters or digits are skipped into `OUTPUT.skippedSearches`; when no usable entry remains the run ends as `no_results`. Values within a list are combined; filters across fields must all match. Disjoint known `sports` and `leagues`, or `nextDays` with explicit dates, fail before collection.

### Input

| Field | Meaning | Omitted behavior / limits |
| --- | --- | --- |
| `sports` | Sport names or supported league codes | All observed sports; basketball, american_football, canadian_football, ice_hockey, esports, tennis, golf, mma |
| `leagues` | NBA, NFL, NHL, NCAAF/CFB, NCAAB/CBB, CFL, CS/CS2, DOTA, LOL, tennis, PGA, MMA/UFC | All supported leagues; availability varies with the slate |
| `statTypes` | Exact native or normalized stat keys | All; examples: receiving_yds, receiving_yards, points |
| `periods` | Normalized output values: `game`, `first_period`, `second_period`, `third_period`, `fourth_period`, `first_half`; full game is `game` | All periods; unknown values are skipped into `OUTPUT.skippedSearches` |
| `players` | Exact full names or native player IDs | All; name comparison ignores accents and punctuation |
| `teams` | Exact player-team abbreviation or full name | All; compares with player.team and player.teamName |
| `gameDateFrom` | Inclusive UTC game date, YYYY-MM-DD | No lower date bound |
| `gameDateTo` | Inclusive UTC game date, YYYY-MM-DD | No upper date bound; must not precede gameDateFrom |
| `nextDays` | Today through today + N − 1 in UTC | Omitted; integer 1–30; cannot combine with explicit dates |
| `includeAlternates` | Include other offers present for a market | false; does not promise a complete alternate ladder |
| `includeLive` | Retain live and non-pregame offers present | false; no promise of complete in-play coverage |
| `maxResults` | Maximum delivered prop/change rows | 20 for bare input, otherwise 5,000; integer 1–10,000 |
| `onlyChangesSinceLastRun` | Baseline followed by changes | false |
| `stateKey` | Persistent history name shared by matching filters | default; non-empty string, at most 200 characters |
| `proxyConfiguration` | Optional connection settings | Omitted; no configured service required by default |
| `downloadTimeoutSecs` | Deadline for acquiring the complete board | 90 seconds; integer 1–1,200; run timeout also covers saving |
| `allowPartial` | Deliver complete, joined rows from an incomplete board | false; incomplete collection normally fails |

To collect only full-game props, use:

```json
{"periods": ["game"]}
```

Period values ignore case and surrounding whitespace. An explicit list excludes rows with an unknown (`null`) period. Period filtering happens before enrichment and delivery; excluded props incur no record fee. The run start fee still applies.

### Output

One dataset row represents one player/stat market/provider, including both sides. A missing selection remains present with `available: false`. Native payout values remain under `sides`; fantasy multipliers are never converted to probabilities or sportsbook prices. Unknown normalized stats, ESPN IDs, settlement rules and overtime coverage remain null. `matchKey` is a comparison aid built from league, normalized player name and team (league and name for solo sports); it is not a verified cross-provider ID.

Rows also include `recordKey`, stable `propKey`, `snapshotKey`, `canonical` version 1.0, nullable `quote` version 1.1, source timestamps, collection timestamps, suspension flags and optional alternates. Changed rows add `changeType`, `changedFields` and `previous`. Compare the same period and scoring rules; a first-half line differs from a full-game line.

The key-value store `OUTPUT` contains row counts by sport, league and stat, request and byte totals, failures, missing-data diagnostics, sample/baseline flags, caps reached and `summaryLine`. The terminal status message matches that summary. Summaries and errors are not dataset rows.

### Output example

**Selected fields only.**

A real row delivered by the Actor entrypoint from the complete November 11, 2026 capture:

```json
{
  "propKey": "underdog:0004b884-9d7b-412d-a40a-42310d628b3e:manual",
  "source": "underdog",
  "league": "ncaaf",
  "player": {
    "nativeId": "93398dff-c2c8-4f6c-8ee3-f28b2050ddbc",
    "name": "Ty Clark",
    "team": "WAKE",
    "teamName": "Wake Forest Demon Deacons",
    "teamNativeId": "629be65c-616e-4c16-9b22-6228a373b826",
    "position": "RB",
    "espnPlayerId": null,
    "sportradarId": null
  },
  "statTypeNative": "rush_rec_tds",
  "statType": "touchdowns",
  "line": 0.5,
  "espnPlayerId": null,
  "matchKey": "ncaaf:tyclark:wake"
}
```

### Pricing

**$0.00015 per prop record ($0.15 per 1,000) plus $0.01 per run start**. Under pay per event there is no separate compute or proxy charge.

Higher and Lower together count as one prop record; nested alternates do not add records. A 20-record sample costs $0.013 ($0.003 + $0.01). All 9,773 records in the captured board cost $1.47595 ($1.46595 + $0.01). All 3,112 captured NFL props cost $0.4768. An unchanged check delivers zero records and costs the $0.01 run start. A start-only charge limit does not advance the baseline. These examples assume the stated rates and sufficient charge and output limits; future board sizes vary.

Only delivered records count toward the record fee. A charge limit may deliver fewer rows; the summary reports “allowed N of M”, and undelivered changes remain pending for later runs. For example, a $0.01045 run limit permits the start plus three records at these rates. Set `maxResults: 10000` to request the whole captured board; an explicit scope otherwise defaults to 5,000.

### Scheduling and monitoring

Run this input repeatedly with the same `stateKey` and filters:

```json
{"leagues":["nfl"],"statTypes":["receiving_yards"],"maxResults":20,"onlyChangesSinceLastRun":true,"stateKey":"nfl-receiving-watch"}
```

The first run emits a labelled baseline. Later runs emit `new`, `line`, `payout`, `status` or `removed` records, with prior values. A row can list several changed fields. Unchanged props produce no row. Only delivered observations advance saved history; capped rows can appear next time. A new state name starts fresh history. Changing filters, including adding, removing or changing `periods`, starts a separate baseline in a separate history; changing the cap preserves it.

Incomplete observations never infer removals. A completely empty league preserves its prior props conservatively. Check `stateSaved` and warnings; a storage failure can cause changes to repeat. Only one run may write the same history at a time. An overlapping run fails before collection and names `stateKey`; a different state name can run independently. If a run is killed, its history lock can remain until its timeout plus 60 seconds. History is bounded to 10,000 observations; new props remain pending if delivered removals must first free space. Corrupted or oversized history fails with a `stateKey` error instead of resetting it. Earlier version 1 history records remain readable.

### Run time

A filtered sample still acquires the whole available board. A complete platform observation on November 11, 2026 received about 2.85 MB compressed / 25.997 MB decoded in 4.2 seconds, with about 105 MB peak memory during the observed download. The saved gzip is 2.636 MB. Small output limits reduce saved rows, but do not reduce acquisition. There is one board request per run.

The default download deadline is 90 seconds; the default run ceiling is 900 seconds at 512 MB. Complete-capture local replays at approximately one eighth CPU delivered 9,773 rows in 66.8 seconds using 308 MiB peak memory and a saved baseline in 79.9 seconds using 308 MiB. With every line deliberately moved, the change replay delivered all 9,773 changes in 87.8 seconds using 340 MiB; its unchanged repeat delivered zero rows in 33.7 seconds. The 20-row sample finished in 19.4 seconds using 89 MiB and normalized only the requested sample. Acquisition still reads the complete document. These are replay measurements; platform storage and network times can differ. Results are saved incrementally in small batches. Near the run deadline, collection stops with a partial summary and preserves only delivered history so the remainder can appear next time.

A cut-off collection fails with a reason. Explicit `allowPartial: true` retains fully read, joined props and reports missing arrays, unfinished records and unresolved lines. Unseen remainder size is unknown. Partial results never infer removals.

### Limits and freshness

The complete capture contains NBA, NFL, NHL, college football (NCAAF/CFB), college basketball (NCAAB/CBB), CFL, Counter-Strike (CS/CS2), Dota 2, League of Legends, tennis, PGA-labelled golf and UFC-labelled MMA. These labels describe source coverage, not a guarantee of every event or future slate. Golf's captured event is the Austin Championship. There is no MLB or WNBA evidence in this capture. Solo sports use participant names or a round title and have no player team.

All 9,773 captured lines became rows, with zero skipped lines. This snapshot has balanced pregame offers only. `hasAlternates` is a source hint; alternate ladders, discounts, boosts, live lines and expirations have no real examples here. Suspended options and missing sides are observed and retained. Native payout metadata stays under `sides.payoutInfo`; multipliers are separate from American and decimal prices.

Data describes the board during collection, not historical or guaranteed closing lines. `sourceUpdatedAt` is the latest timestamp among a line and its options, or null. All 9,773 rows have name-based `matchKey` values, with no collisions across the 1,614 native players in this capture; this does not verify any cross-provider identity. **Zero of 1,614 players can be mapped to ESPN IDs from the supplied document alone.** ESPN player/event IDs remain null; no enrichment is performed. CFL has abbreviations but no full team names in the document.

Unknown stats retain `statType: null`; 7,173 captured rows have normalized stat aliases. Native stat labels preserve source scope. The 290 offers scoped to map/game subsets (including ten three-map fantasy offers) have `period: null` and `quote: null` because quote version 1.1 has no corresponding period. They remain honest native prop rows with their scope in `statTypeNative` and the canonical native stat; they are not labelled full-game quotes. The other 9,483 rows carry quote version 1.1. Scoring rules, overtime coverage and entry-size payouts are unverified.

Collection is bounded at 128 MiB received and 256 MiB decoded. Output is capped at 10,000 rows per run. A sample does not promise equal representation by league. All date filters use UTC. Filter values compare exactly after case, accent, Latin-letter and punctuation normalization; substrings do not match. An unknown value succeeds empty and is named in `OUTPUT.unmatchedFilters` and the terminal summary.

### FAQ

**Can I get only one player or stat?** Yes. Use an exact name/native ID or native/normalized stat key. Filters apply after the board is acquired.

**Are both selections always available?** No. One-sided and suspended props retain explicit unavailable selections. Do not infer a missing price.

**Does it provide historical lines?** No. Schedule repeated runs to build observations from your own collection times.

**How do I export results?** Use the default dataset's JSON, CSV, Excel or other supported Apify exports. Keep nested sides in JSON for lossless payout detail.

**What if nothing matches?** A complete valid collection succeeds empty and explains this in `OUTPUT`. A failed collection ends FAILED; an explicitly permitted partial result names its gaps.

# Actor input Schema

## `sports` (type: `array`):

Exact canonical sports or league codes/names; case and accents ignored. Includes basketball, american_football, canadian_football, ice_hockey, esports, tennis, golf, mma. Omit for all; unknown values succeed empty. Maximum 200 distinct values, 200 characters each; duplicate normalized values and entries without Latin letters/digits fail.

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

Exact league codes/names: NBA, NFL, NHL, NCAAF/CFB, NCAAB/CBB, CFL, CS/CS2, DOTA/Dota 2, LOL, tennis, PGA, MMA/UFC. Omit for all. Unknown values succeed empty and are reported. Maximum 200 distinct values, 200 characters each; duplicate normalized values and entries without Latin letters/digits fail.

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

Exact native stat keys or normalized sportsbook keys. Unknown source stats retain a null normalized value. Omit for all. Maximum 200 distinct values, 200 characters each; duplicate normalized values and entries without Latin letters/digits fail.

## `periods` (type: `array`):

Normalized output periods: game, first_period, second_period, third_period, fourth_period, first_half. Full game is game. Omit for all, including unknown periods; explicit empty lists and unknown values fail. Compared ignoring case and surrounding whitespace.

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

Exact full player names (accent/punctuation insensitive) or native Underdog player IDs. Omit for all; explicit empty lists fail. Maximum 200 distinct values, 200 characters each; duplicate normalized values and entries without Latin letters/digits fail.

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

Exact player-team abbreviation or full name derived from game titles. Case and accents ignored. Solo players have no team. Omit for all; explicit empty lists fail. Maximum 200 distinct values, 200 characters each; duplicate normalized values and entries without Latin letters/digits fail.

## `gameDateFrom` (type: `string`):

Inclusive UTC game date, YYYY-MM-DD. Cannot be combined with nextDays.

## `gameDateTo` (type: `string`):

Inclusive UTC game date, YYYY-MM-DD. Must not precede gameDateFrom.

## `nextDays` (type: `integer`):

Inclusive UTC today through today + N - 1 days, 1–30. Omit for the entire available slate; cannot combine with explicit dates.

## `includeAlternates` (type: `boolean`):

False in code. Other offers in the same market/provider are nested under alternates when true; this capture has balanced offers only, despite has_alternates hints.

## `includeLive` (type: `boolean`):

False in code. True retains any live/non-pregame offers present in the board. Does not promise complete in-play coverage.

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

Maximum delivered prop rows, 1–10000. Bare input uses 20; explicit scope uses 5000 when omitted. Capped change rows stay pending.

## `onlyChangesSinceLastRun` (type: `boolean`):

False in code. First run emits a labelled baseline; subsequent runs emit new, line, payout, status and removed props. Saved state advances only for delivered rows.

## `stateKey` (type: `string`):

Non-empty name up to 200 characters; code uses default when omitted. Same name and filters share history in a persistent named key-value store. New name resets history.

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

Optional; omitted means direct access. Apify Proxy is disabled locally. Set useApifyProxy false for direct collection.

## `downloadTimeoutSecs` (type: `integer`):

Whole-download deadline, 1–1200 seconds; code uses 90 when omitted. Platform observation: about 26 MB decoded in 4.2 seconds; run timeout also covers processing and saving.

## `allowPartial` (type: `boolean`):

False in code. A cut-off or unresolved board fails by default. True delivers fully parsed, joined rows only, reports missing data and never infers removals.

## Actor input object example

```json
{
  "leagues": [
    "nba",
    "nfl"
  ],
  "includeAlternates": false,
  "includeLive": false,
  "maxResults": 20,
  "onlyChangesSinceLastRun": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "allowPartial": false
}
```

# Actor output Schema

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

No description

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

No description

# 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": [
        "nba",
        "nfl"
    ],
    "includeAlternates": false,
    "includeLive": false,
    "maxResults": 20,
    "onlyChangesSinceLastRun": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "allowPartial": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/underdog-player-props").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": [
        "nba",
        "nfl",
    ],
    "includeAlternates": False,
    "includeLive": False,
    "maxResults": 20,
    "onlyChangesSinceLastRun": False,
    "proxyConfiguration": { "useApifyProxy": False },
    "allowPartial": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/underdog-player-props").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": [
    "nba",
    "nfl"
  ],
  "includeAlternates": false,
  "includeLive": false,
  "maxResults": 20,
  "onlyChangesSinceLastRun": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "allowPartial": false
}' |
apify call automatic/underdog-player-props --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/underdog-player-props"
        }
    }
}
```

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/kJ2117fCVXO1VEro0/builds/BdtN6tPuXSOwlse3e/openapi.json
