# Sleeper Picks Player Props (`automatic/sleeper-player-props`) Actor

Collect NBA and NFL Sleeper Picks props with paired sides, lines, multipliers and native IDs. Filter by player, team, stat and game date; monitor new, line, payout, status and removed props with a saved baseline.

- **URL**: https://apify.com/automatic/sleeper-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

## Sleeper Picks Player Props

Collect NBA and NFL Sleeper Picks player props for DFS research: one record per prop with both sides, the line, side multipliers, native player and game IDs, teams and game start time. Filter a snapshot or retain a baseline and receive subsequent changes.

### Use cases

- Shop DFS lines across saved Sleeper snapshots and other licensed data sources.
- Compare player props with sportsbook lines using player, event, stat and period.
- Feed current lines and multipliers into models while keeping fantasy scoring separate.
- Schedule alerts for line moves, payout changes, suspensions and disappearing props.

### Also available

The player props suite: pick the job.

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

### Quick start

Run with the Console prefill to collect up to 20 NBA/NFL props:

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

A bare `{}` runs an announced sample of up to 20 available NBA/NFL props and sets `OUTPUT.sampleRun: true`. It tries NBA first, then NFL if needed, and stops enrichment as soon as the sample is full. If no pre-game props exist, bare input may return currently available live offers with an explicit warning and `OUTPUT.sampleLiveFallback: true`; an explicit `includeLive: false` always excludes them. Between supported slates it succeeds with zero rows and an explanation. Explicit scope uses up to 5,000 rows when `maxResults` is omitted.

### Input

Omit optional filters to include everything in scope. Explicit empty lists, empty strings and nulls end the run as `no_results` and name the field. One unusable or duplicate entry is skipped and reported in `OUTPUT.skippedSearches`; the rest still runs. Lists combine with OR internally; different filters combine with AND. Each list accepts at most 100 entries of 1–200 characters. Filters ignore case, accents and punctuation; use `nba`/`nfl` for leagues and the documented sport names. Strings that normalize to no letters or digits end the run as `no_results`.

| Field | Code behavior when omitted | Meaning |
| --- | --- | --- |
| `sports` | Both supported sports | `basketball`, `american_football`, or Sleeper codes `nba`, `nfl`. Must agree with `leagues` if both are given. |
| `leagues` | NBA and NFL | Select `nba` and/or `nfl`. Other Sleeper competitions are outside this release. |
| `statTypes` | All stats | Exact native or normalized keys, such as `threes_made`, `threes`, `passing_yards`. Unknown keys honestly match zero. |
| `periods` | All periods | Normalized output values: `game`, `first_period`. Full game is `game`; an unknown value is skipped and reported in `OUTPUT.skippedSearches`; if no usable period remains the run ends as `no_results`. |
| `players` | All players | Exact full names, ignoring accents, punctuation and case, or native Sleeper player IDs. |
| `teams` | All teams | Player team abbreviations as Sleeper writes them, for example TOR or NYG. |
| `gameDateFrom` | No lower date bound | Inclusive UTC game date, YYYY-MM-DD. |
| `gameDateTo` | No upper date bound | Inclusive UTC game date, YYYY-MM-DD; must follow or equal the lower bound. |
| `nextDays` | No relative date bound | 1–30 UTC days, including today. Cannot combine with explicit dates. |
| `includeAlternates` | false | Include alternate lines supplied on the same board. Does not guarantee additional ladders. |
| `includeLive` | false | False keeps pre-game offers. True also retains other game states present on the board; complete in-play coverage is unverified. |
| `maxResults` | 20 for sample; 5,000 for explicit scope | Maximum 1–10,000 delivered rows. Observed undelivered changes are saved in a separate pending queue. |
| `onlyChangesSinceLastRun` | false | First check emits `baseline`; later checks emit `new`, `line`, `payout`, `status` and `removed`. |
| `stateKey` | default | History name, up to 200 characters. Same name plus same filters continues a feed; a new name resets it. |
| `proxyConfiguration` | Direct access | Optional connection settings. Omit for normal use. |

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

A dataset row contains stable `propKey` and `recordKey`, a content `snapshotKey`, `sport`, `league`, `game`, `player`, native and normalized stat type, `period`, `line`, `lineRaw`, `sides`, optional `alternates`, status and suspension flags, source update time, collection time, and first/last observation times. First seen is scoped to this run in snapshot mode and to observed history delivered by the feed in change mode, including the original observation time of queued rows. Missing information is null. An unavailable side remains explicit with a null multiplier.

The `quote` block follows the same version 1.1 shape as our sportsbook player props, and `canonical` follows envelope 1.0. DFS multipliers stay in `sides` and the Sleeper extension; sportsbook odds and implied probabilities remain null. First-quarter props use `first_period`. Unmapped stats, including Sleeper fantasy points, have a null normalized stat and keep their native key. Overtime and settlement rules are unknown and must be checked before comparing prices.

`espnPlayerId` is populated only when supplied with the native player record. A captured NBA sample had 0/131 player IDs; NFL had 60/194. `matchKey` is `<league>:<folded player name>:<folded player team>`; folding removes accents, punctuation and case. It stays stable across option-ID and line changes, but a player name or team change changes this matching aid. It is used for matching possibilities, and is not a verified cross-source identity. ESPN event IDs remain null. Match both teams, game time, player, stat, period and settlement before comparing; different lines can be compared as lines, while odds comparisons require identical lines and rules.

The `OUTPUT` summary includes pending counts, queued deliveries and whether the board was refreshed. It reports delivered counts by sport, league and stat, source market counts, requests, compressed body bytes, decoded bytes, failures by reason, caps, baseline/change counts, state-save status and `summaryLine`. Delivery counts refer to written rows; source, matching and pending counters describe their named stages. Completed league batches are saved before collecting the next league. Source failures write no diagnostic dataset rows. A collection deadline reserves time to save partial results and a terminal summary. Partial failures name the affected league and preserve its history.

### Output example

Selected fields from a real captured NBA record on 2026-11-11; no values below are invented:

```json
{
  "propKey": "sleeper:nba:2026:regular:1393723855800893440:1718:assists:over_under",
  "league": "nba",
  "game": {
    "nativeId": "1393723855800893440",
    "startTime": "2026-11-12T00:00:00.000Z",
    "home": "TOR",
    "away": "BOS",
    "espnEventId": null,
    "status": "pre_game"
  },
  "player": {
    "nativeId": "1718",
    "name": "Jakob Poeltl",
    "team": "TOR",
    "position": "C",
    "espnPlayerId": null,
    "sportradarId": "e1b3d3d5-b4b1-481a-b5b9-efe4231f48bf"
  },
  "statTypeNative": "assists",
  "statType": "assists",
  "period": "game",
  "line": 1.5,
  "sides": [
    {
      "role": "over",
      "nativeOutcome": "over",
      "nativeId": "1426347781999566866",
      "line": 1.5,
      "payoutMultiplier": 1.65,
      "payoutMultiplierRaw": "1.65",
      "status": "active",
      "available": true,
      "payoutInfo": {}
    },
    {
      "role": "under",
      "nativeOutcome": "under",
      "nativeId": "1426347781999566867",
      "line": 1.5,
      "payoutMultiplier": 1.93,
      "payoutMultiplierRaw": "1.93",
      "status": "active",
      "available": true,
      "payoutInfo": {}
    }
  ],
  "espnPlayerId": null,
  "matchKey": "nba:jakobpoeltl:tor",
  "sourceUpdatedAt": "2026-11-11T20:52:01.910Z",
  "collectedAt": "2026-11-11T21:14:48.282Z"
}
```

### Pricing

**$0.00015 per prop record ($0.15 per 1,000) plus $0.01 per run start**.

Examples: a 20-prop sample costs $0.013; 1,000 props cost $0.16; a 2,000-prop pull costs $0.31. An unchanged check with no delivered records costs $0.01 for the run start. Under pay per event there is no separate compute or proxy charge.

One dataset item is one prop with both sides; alternates are nested in that item. Only delivered dataset items incur the per-record charge; the run start fee also applies. Unchanged checks deliver no rows. A charge cap reports how many rows were allowed and leaves remaining changes pending. Include both record charges and run starts when budgeting a schedule.

### Scheduling and monitoring

Use a fixed scope and state name, then run the following input twice or on a schedule:

```json
{
  "leagues": ["nba"],
  "players": ["Jakob Poeltl"],
  "onlyChangesSinceLastRun": true,
  "stateKey": "nba-poeltl-monitor"
}
```

The first observed board labels its baseline; capped baseline rows retain that label when delivered later. Later observations return changed rows with `previous` values and `changeType`; baseline/new rows have no previous record. Quiet checks succeed with zero rows. Status changes are included even if the line stays fixed. Removed means absent from the selected scope, including a pre-game prop leaving that scope at game start. A whole empty league slice with saved props is treated cautiously: it preserves history and reports a warning instead of inferring mass removals.

Changing filter meaning, including adding, removing or changing `periods`, starts a separate baseline even with the same state name. Changing only `maxResults` keeps the same history. Relative `nextDays` windows roll with UTC dates. Avoid overlapping schedules using the same state name and scope; state updates are not transactional across concurrent runs. Schedule at a cadence suitable for the source's freshness and your budget. No automatic notifications are sent; consume changed dataset rows in your own alert workflow.

### Limits and freshness

NBA and NFL only. This Actor observes the currently available board, not every sport Sleeper offers. At most 10,000 delivered props per run. Saved state, including delivered records and queued observations together, is limited to 10,000 records and 64 MiB; malformed or incompatible older state fails before source requests and requires a fresh state name. No historical backfill, settled results, certified closing prices, complete entry-size payout tables, power/flex rules or derived fair probabilities are provided. Native option IDs can change while `propKey` remains stable. No alternate offers were observed in the captured NBA/NFL board; support is limited to alternate offers present there.

Snapshot runs and change runs without a remaining backlog check the board anew. Change runs drain saved pending observations first; if a delivery or charge cap stops the run, it reports that the current board was not refreshed. Queued records retain their original observation timestamps, even if the source has since moved or removed them. They matched the filters when captured and may fall outside a later rolling nextDays window when delivered. Unobserved historical moves are not reconstructed. Player metadata can be cached for 24 hours and game metadata for 15 minutes. `sourceUpdatedAt` reflects the source's own timestamp and is not an update-frequency guarantee; timestamps can refresh without line movement. This is a snapshot service and offers no real-time latency guarantee. Missing native game/player enrichment causes that league to be skipped with a named failure. A fully failed run ends FAILED; a genuinely empty scope is a successful zero-row result.

### FAQ

**Can I collect only one league or stat?** Yes, set `leagues` or `statTypes`. Sports and league filters must agree.

**Does a multiplier mean decimal odds?** No. A pick multiplier is retained as source payout information. It does not establish slip payouts or fair win probability.

**Can I join ESPN or sportsbook props automatically?** Native Sleeper IDs join within Sleeper. External IDs are incomplete; `matchKey` alone is insufficient. Verify event and settlement semantics before merging.

**Why did a quiet monitor produce no rows?** No selected prop changed relative to the observations delivered under that state name. Check `OUTPUT` for failures, caps and state-save warnings.

**Can I export the data?** Use Apify dataset exports such as JSON, CSV or Excel. JSON preserves nested sides, games and prior values most clearly.

**Can I recover last month's closing lines?** No. Schedule forward snapshots; this Actor does not retrieve a historical archive or certify an official close.

# Actor input Schema

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

Supported sports: basketball and american_football, or Sleeper nba/nfl codes. Omit for both. Explicit empty lists fail. At most 100 unique entries, each at most 200 characters; duplicates fail. Codes are validated at run start, ignoring case and accents.

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

NBA and NFL. Omit for both. Bare input returns a sample of up to 20 props; other Sleeper leagues are not supported in this release. At most 100 unique entries, each at most 200 characters; duplicates fail. Codes are validated at run start, ignoring case and accents.

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

Exact native stat keys or normalized sportsbook keys, such as points, threes or passing_yards. Omit for all. Explicit empty lists fail. At most 100 unique entries, each at most 200 characters; duplicates fail.

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

Normalized output periods: game, first_period. 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 Sleeper player IDs. Omit for all; explicit empty lists fail. At most 100 unique entries, each at most 200 characters; duplicates fail.

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

Sleeper team abbreviations, such as TOR or NYG. Filters the player team. Omit for all; explicit empty lists fail. At most 100 unique entries, each at most 200 characters; duplicates 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. Include alternate offers exposed with the board in the alternates array; does not promise extra ladders.

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

## Actor input object example

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

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/sleeper-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 },
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/sleeper-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
  }
}' |
apify call automatic/sleeper-player-props --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/sleeper-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/vcFSlLPbCInikQkAY/builds/e6T7Yet7LodRrwtHb/openapi.json
