# Sleeper Picks Scraper — Props, Multipliers & Pick Popularity (`logiover/sleeper-picks-scraper`) Actor

Unofficial Sleeper Picks API, no key, no login. Every live player prop line, one row per prop with over and under payout multipliers, odds, pick popularity, recent form, injury status and matchup for NFL, CFB, NBA, NHL, soccer, MMA, tennis, golf, CS2. JSON, CSV, Excel.

- **URL**: https://apify.com/logiover/sleeper-picks-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, AI, 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.15 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper — Props, Multipliers & Pick Popularity

> **Not affiliated with Sleeper.** This Actor is independent: it is not made, endorsed or sponsored by Sleeper or any league, team or sportsbook. It reads only the board that Sleeper publishes to every visitor and app user — no login, no account, no bets placed. "Sleeper" and every league name belong to their owners and are used here only to say what the data is about.

**Sleeper Picks Scraper** turns the live Sleeper Picks board into a clean table: one row per prop, with the over and the under side by side — payout multipliers, American odds, implied and no-vig probabilities — plus pick counts and popularity score, the player's last ten games for that stat, injury status, matchup, venue, TV channel and start time. It is a **Sleeper Picks API** without a key: run it from the Console or call it from code, and get JSON, CSV or Excel for **NFL, college football, NBA, WNBA, NHL, soccer (EPL, La Liga, Serie A, Bundesliga, Ligue 1), MMA, tennis, golf and CS2** — whichever leagues Sleeper has lines posted for at that moment. A board of 3,367 lines is 3,367 rows (one per player, stat and game) that you can filter, join and chart without unpacking anything. If you would rather have the over and the under as separate rows with their own ids, flip one switch.

Use it as a **player props API**, a **DFS pick'em scraper**, a **line shopping** feed next to sportsbook odds, a **prop model** input (implied and no-vig probability, hit rates), an **injury** monitor, or the start of a **line movement** and **closing line value** archive built from scheduled runs. The columns are named like our PrizePicks Scraper (`playerName`, `statType`, `lineScore`, `oddsType`, `startTime`, `projectionId` …), so a Sleeper row and a PrizePicks row can be stacked in one sheet. Export to **Google Sheets, Excel, BigQuery, Snowflake, Airtable, n8n, Make or Zapier** — and nothing here needs a Sleeper account, a headless browser or a proxy bill.

### Table of contents

- [At a glance](#at-a-glance)
- [What you get](#what-you-get)
- [Who uses it and how](#who-uses-it-and-how)
- [Cookbook: ready-made inputs](#cookbook-ready-made-inputs)
- [Quick start: Console](#quick-start-console)
- [Quick start: API](#quick-start-api)
- [Input reference](#input-reference)
- [Data dictionary](#data-dictionary)
- [Scale, speed and measurements](#scale-speed-and-measurements)
- [What you pay](#what-you-pay)
- [Integrations and scheduling](#integrations-and-scheduling)
- [Performance tips](#performance-tips)
- [Troubleshooting](#troubleshooting)
- [Honest limits](#honest-limits)
- [Comparison with the other ways to get this data](#comparison-with-the-other-ways-to-get-this-data)
- [Frequently asked questions](#frequently-asked-questions)
- [Glossary](#glossary)
- [Legal and responsible use](#legal-and-responsible-use)
- [Changelog](#changelog)
- [Support](#support)

### At a glance

| | |
|---|---|
| What it reads | The public Sleeper Picks board (all lines, both sides), the promo board, the scoreboard and the player catalogue |
| Login / API key | None. No account, no cookies, no browser |
| Leagues | NFL, CFB, NBA, WNBA, NHL, MLB (when posted), soccer (EPL, La Liga, Serie A, Bundesliga, Ligue 1, MLS), MMA, tennis, golf, CS2 — all that are live |
| Default output | One row per line (player × stat × game) with both sides in the row — 102 columns |
| Other shapes | One row per side (`rowShape: side`, 115 columns); extra rows for each past game in a line's history (`includeRecentGames`) |
| Board size on 2026-10-29 | 3,367 lines (= 6,734 sides) in 14 leagues, 1,267 players, 152 games |
| Biggest proof run | 34,208 unique rows in 21.2 seconds on 2026-10-29 — `rowShape: side` plus `includeRecentGames` (6,734 side rows + 27,474 recent-game rows) |
| Speed | Console prefill (100 lines) in 2.7 s, first row after 1.4 s; 1,000 lines in 3 s |
| Filters | League, stat type, player, team, side, multiplier range, minimum picks, promos, start window |
| Price | Pay per result: $0.25 per 1,000 rows on the Free plan, $0.15 on Gold and above. Set a maximum cost per run and it stops there |
| Export | JSON, CSV, Excel, XML, RSS, HTML, or straight into Sheets, Airtable, a webhook or a warehouse |
| Refresh | Lines change every few minutes; Sleeper's edge cache keeps a board about 30 seconds |

### What you get

#### The board, row by row

A Sleeper "line" is a player, a stat and a game: *Aaron Wiggins, Points, 11.5, Cleveland at Atlanta*. Sleeper lets you pick the **over** or the **under**, and each side carries its own **payout multiplier** — 1.75 for the over and 1.81 for the under, for example — and its own Sleeper id. The Actor writes the line as one row that holds both sides, then joins everything Sleeper knows about it:

- **The market** — league, stat (`Points`, `Pts + Rebs + Asts`, `Kills (Maps 1+2)` …), Sleeper's stat key, the line value, the golf round.
- **The price** — over and under multipliers and line ids, each side as American odds, implied and no-vig probability, and the overround.
- **The crowd** — picks on the over, the under and in total, each side's share, Sleeper's 0–1 popularity score.
- **The form** — the player's last games for that exact stat (up to ten: date, opponent, value), the average, how many cleared the line, fell short or landed on it, and each side's hit rate.
- **The player** — name, team, position, headshot, age, college, injury status and note, depth chart slot, ids at Sportradar, ESPN, Yahoo, Rotowire, FantasyData and OddsJam.
- **The game** — start time (UTC), opponent, home or away, both teams with records, venue, TV channel, event or tournament, weight class, fixture ids.
- **The promotion** — boosted or discounted promo, which kind, whether Sleeper shows it as a free pick.

Everything is a flat column: no nested JSON you have to unpack (the recent-game history is the one array, and it is optional to use because the same facts are also in plain columns).

#### Three kinds of rows

| `recordType` | When | What one row is |
|---|---|---|
| `line` | default | one whole line with both sides in the row (`overMultiplier` and `underMultiplier`, `overOddsAmerican` and `underOddsAmerican`, the pick counts of both sides …) |
| `side` | `rowShape: side` | one side of one line — the unit Sleeper itself prices and ids (`lineId`) — with the line's columns repeated; twice the rows |
| `recentGame` | `includeRecentGames: true` | one past game from a line's history, with its value and whether it went over, under or pushed against the current line |

All three kinds share the unique `rowId`, so mixing them in one dataset never creates a duplicate, and `projectionId` / `lineKey` link a side row or a recent-game row back to its line.

#### A real row

This is one line row from a platform run on 2026-10-29 (the Console prefill). Empty columns, the external ids and some profile columns are left out here for space; everything shown is as written to the dataset:

```json
{
  "rowId": "sleeper:line:1421427865261535255",
  "recordType": "line",
  "projectionId": "1421427865261535255",
  "lineKey": "nba:1393723788809469952:2299:points",
  "playerId": "2299",
  "playerName": "Aaron Wiggins",
  "playerTeam": "ATL",
  "playerPosition": "SF",
  "jerseyNumber": "2",
  "league": "NBA",
  "sport": "basketball",
  "sleeperSport": "nba",
  "statType": "Points",
  "statDisplayName": "Points",
  "wagerType": "points",
  "lineScore": 11.5,
  "overMultiplier": 1.75,
  "underMultiplier": 1.81,
  "overLineId": "1421427865261535255",
  "underLineId": "1421427865261535256",
  "overOddsAmerican": -133,
  "underOddsAmerican": -123,
  "overImpliedProbability": 0.5714,
  "underImpliedProbability": 0.5525,
  "overNoVigProbability": 0.5084,
  "underNoVigProbability": 0.4916,
  "marketOverround": 0.1239,
  "lineType": "normal",
  "oddsType": "standard",
  "isPromo": false,
  "isLive": false,
  "gameStatus": "pre_game",
  "startTime": "2026-10-30T00:00:00Z",
  "updatedAt": "2026-10-29T07:02:03.010Z",
  "scrapedAt": "2026-10-29T09:59:39.169Z",
  "gameId": "1393723788809469952",
  "gameWeek": 2,
  "season": "2026",
  "seasonType": "regular",
  "opponent": "CLE",
  "isHome": true,
  "homeTeam": "ATL",
  "awayTeam": "CLE",
  "homeTeamRecord": "2-3",
  "awayTeamRecord": "3-1",
  "matchup": "CLE @ ATL",
  "venueName": "State Farm Arena",
  "venueCity": "Atlanta",
  "tvChannel": "NBA TV",
  "pickCountOver": 214,
  "pickCountUnder": 8,
  "pickCountTotal": 222,
  "pickShareOver": 0.964,
  "pickShareUnder": 0.036,
  "pickPopularity": 0.9384,
  "recentGamesCount": 5,
  "recentAverage": 14.6,
  "recentOverCount": 4,
  "recentUnderCount": 1,
  "recentPushCount": 0,
  "recentHitRateOver": 0.8,
  "recentHitRateUnder": 0.2,
  "recentGames": [{"date": "2026-10-21", "opponent": "ORL", "value": 16}, {"date": "2026-10-23", "opponent": "CHA", "value": 19}, {"date": "2026-10-24", "opponent": "HOU", "value": 16}, {"date": "2026-10-26", "opponent": "HOU", "value": 12}, {"date": "2026-10-28", "opponent": "MIA", "value": 10}],
  "playerAge": 27,
  "depthChartOrder": 2
}
```

A recent-game row (`includeRecentGames`) is much shorter — 26 columns: the line's key fields plus `pastGameDate`, `pastOpponent`, `pastValue`, `pastResult` (`over`, `under` or `push` against the current line) and `pastMargin`.

#### Which leagues and stats are on the board

Sleeper decides what is posted, and it changes through the day. On 2026-10-29 the board held these leagues (side rows are two per line; the line count is half of that):

| League code | Competition | Side rows | Recent-game rows |
|---|---|---:|---:|
| `CFB` | College football | 1,890 | 6,291 |
| `NFL` | NFL | 1,852 | 8,880 |
| `NHL` | NHL | 1,308 | 6,391 |
| `NBA` | NBA | 614 | 1,205 |
| `CS2` | Counter-Strike 2 | 552 | 2,644 |
| `TENNIS` | Tennis | 124 | 620 |
| `WNBA` | WNBA | 102 | 510 |
| `MMA` | MMA / UFC | 98 | 107 |
| `GOLF` | Golf | 78 | 390 |
| `LALIGA` | La Liga (soccer) | 36 | 161 |
| `EPL` | Premier League (soccer) | 36 | 128 |
| `BUNDESLIGA` | Bundesliga (soccer) | 30 | 94 |
| `LIGUE1` | Ligue 1 (soccer) | 8 | 29 |
| `SERIEA` | Serie A (soccer) | 6 | 24 |

The board had 79 league-and-stat combinations that day. Football lines are dominated by anytime-touchdown and receiving props, basketball by points, rebounds, assists and combinations, hockey by shots, points and assists, esports by kills and headshots over the first two maps, tennis by games, golf by birdies and strokes, MMA by significant strikes and takedowns, and soccer by goalkeeper props (goals against, saves-based fantasy points) with more markets appearing closer to kick-off. Stat keys and labels you have not seen before simply show up in the data: the Actor does not keep a whitelist.

### Who uses it and how

**1. The DFS pick'em researcher.** Sorts the morning board by `pickShareOver` and `recentHitRateOver` and shortlists lines where the crowd leans one way and the last ten games the other: `{"leagues": ["NBA"], "minPickCount": 100}`, then the *Pick popularity* view.

**2. The line shopper.** Keeps Sleeper, PrizePicks and sportsbook prices in one workbook. The columns are named alike (`playerName`, `statType`, `lineScore`, `startTime`), so one lookup finds the same prop everywhere, and `oddsAmerican` puts Sleeper's multiplier on a sportsbook's scale.

**3. The quant building a props model.** `overImpliedProbability`, `overNoVigProbability`, their under twins and `marketOverround` give the market's view of both sides; `recentAverage`, `recentOverCount` and `recentGames` give form; injury columns give availability. One run per slate, appended to a warehouse table keyed by `projectionId`.

**4. The newsletter writer.** Wants "the five most picked unders tonight": sort the line rows by `pickShareUnder` (or ask for `side: under` to get one row per under), join `matchup` and `tvChannel`, paste into the template. `startTime` converts to any time zone.

**5. The Discord or Telegram bot developer.** Schedules a run every few minutes with `startsWithinHours: 3` and `onlyPromos: true`, diffs `projectionId` against the last run and posts new boosted or discounted lines. The stable `rowId` makes de-duplication a set lookup.

**6. The fantasy analyst.** Cares who is hurt before who is picked: `injuryStatus`, `injuryBodyPart`, `injuryNotes` and `depthChartOrder` sit next to the line, so a questionable starter with a soft line stands out.

**7. The data journalist.** Studies crowd behaviour — do users over-pick overs? `pickShareOver` across thousands of lines, split by league and popularity, answers it in a notebook; daily scheduled runs give a time series without scraping code.

**8. The odds-comparison site builder.** Needs a feed with ids: `projectionId`, `overLineId`, `lineKey`, `gameId`, `sportradarGameId` and `oddsjamFixtureId` hang Sleeper's pick'em lines next to sportsbook odds for the same fixture.

**9. The esports analyst.** CS2 lines are kills and headshots over the first two maps; `statType`, `playerTeam`, `opponent`, `eventName` and up to ten earlier matches in `recentGames` support map-pool and opponent studies.

**10. The tennis, golf and MMA specialist.** Tennis rows carry the tournament and opponent for games-played lines, golf rows the tournament and `round`, MMA rows the event, `weightClass` and opponent — with the same pick counts as the team sports.

**11. The data engineer.** Wants a warehouse table: one scheduled run per hour, rows keyed by `rowId`, a typed all-nullable dataset schema that loads into BigQuery or Snowflake without surprises, and `scrapedAt` / `updatedAt` for slowly changing history.

**12. The AI-agent builder.** Gives an assistant the Actor as a tool (Apify's MCP server or the plain API) so it can answer "what are tonight's most-picked NBA unders and who is injured?" from live data.

### Cookbook: ready-made inputs

Paste any of these into the Console's JSON input tab or send them as the run input through the API. Everything not mentioned keeps its default (all leagues, one row per line with both sides, promos included, 20,000 rows maximum).

**1. The whole board.**

```json
{ "maxItems": 0 }
```

Every league with lines, one row per line, no row limit. On 2026-10-29 this was 3,367 rows.

**2. One league.**

```json
{ "leagues": ["NBA"], "maxItems": 0 }
```

Codes are not case-sensitive: `nba`, `NBA` and `Nba` are the same.

**3. Several leagues, one row per side.**

```json
{ "leagues": ["NFL", "CFB"], "rowShape": "side", "maxItems": 0 }
```

The over and the under as separate rows, each with its own `lineId`, `multiplier` and `pickCount` — twice the rows of the default.

**4. Find players.**

```json
{ "playerNames": ["Jokic", "Doncic", "Lamar"], "maxItems": 0 }
```

Case and accents are ignored and partial names work. A player with no lines on the board returns nothing.

**5. Specific stats.**

```json
{ "leagues": ["NBA"], "statTypes": ["Points", "3-Pointers Made", "pts_reb_ast"], "maxItems": 0 }
```

Use the readable name or Sleeper's key. The run summary lists every stat type on the board if a name matches nothing.

**6. Today's games only.**

```json
{ "startsWithinHours": 24, "maxItems": 0 }
```

Or an exact UTC window: `{ "startDateFrom": "2026-11-01", "startDateTo": "2026-11-01" }`.

**7. The long shots.**

```json
{ "minMultiplier": 2.5, "side": "over", "maxItems": 0 }
```

Over sides paying at least 2.5x. Setting `side` switches the output to one row per side; use `maxMultiplier` for the heavy favourites.

**8. What the crowd is picking.**

```json
{ "minPickCount": 200, "maxItems": 0 }
```

Lines with at least 200 picks. Lines Sleeper has no pick statistics for are dropped when this is set.

**9. Boosted and discounted lines.**

```json
{ "onlyPromos": true }
```

A handful of rows at a time: discounted lines (`oddsType: discount`) and boosted multipliers (`oddsType: boost`).

**10. Hit-rate rows.**

```json
{ "leagues": ["NBA"], "includeRecentGames": true, "maxItems": 0 }
```

Adds one `recentGame` row per past game of every NBA line (up to ten), each marked `over`, `under` or `push` against the current line, with `pastMargin`. Each of those rows is a billed result.

**11. Soccer.**

```json
{ "leagues": ["SOCCER"], "maxItems": 0 }
```

Or one competition: `["EPL"]`, `["BUNDESLIGA"]`, `["SERIEA"]`, `["LALIGA"]`, `["LIGUE1"]`, `["MLS"]`.

**12. A small sample of everything.**

```json
{ "maxItems": 100 }
```

When a limit cuts a multi-league board, the rows are a cross-section — every league in turn, soonest games first — rather than only the first league. This is what the Console prefill runs.

### Quick start: Console

1. Open the Actor in the Apify Console and press **Try for free** (or **Start** if you already have an account).
2. Leave the input as it is for a first look: the prefill reads the board and keeps 100 rows, a cross-section of every league that has lines. It finishes in a few seconds.
3. Open the **Dataset** tab. The *Board* view shows league, player, opponent, stat, line, both multipliers and American prices, over pick share, hit rate and start time; other views cover one row per side, probabilities, pick popularity, recent form, injuries, game context and recent-game rows.
4. Narrow it down: pick leagues in the **Leagues** box, type players or teams, set **Minimum picks on the line**, or paste one of the cookbook inputs into the JSON tab.
5. For the whole board set **Max rows** to `0` (no limit). Use **Maximum cost per run** in the run options if you want a hard spending ceiling.
6. **Export** the dataset as CSV, Excel, JSON, XML, RSS or an HTML table, or open it in Google Sheets from the same menu.
7. Use **Schedules** to run it daily, hourly or every few minutes.

### Quick start: API

The Actor id is `logiover/sleeper-picks-scraper`. Replace `<TOKEN>` with your Apify API token (Settings, Integrations).

**Run and wait for the rows (one call):**

```bash
curl -s -X POST "https://api.apify.com/v2/acts/logiover~sleeper-picks-scraper/run-sync-get-dataset-items?token=<TOKEN>&format=json" \
  -H "Content-Type: application/json" \
  -d '{"leagues": ["NBA"], "minPickCount": 50, "maxItems": 0}'
```

**Python (apify-client):**

```python
from apify_client import ApifyClient

client = ApifyClient("<TOKEN>")
run = client.actor("logiover/sleeper-picks-scraper").call(run_input={
    "leagues": ["NBA", "NHL"],
    "minPickCount": 100,
    "maxItems": 0,
})
rows = client.dataset(run["defaultDatasetId"]).list_items().items
print(rows[0]["playerName"], rows[0]["statType"], rows[0]["lineScore"], rows[0]["overMultiplier"], rows[0]["underMultiplier"])
```

**Node.js (apify-client):**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<TOKEN>' });
const run = await client.actor('logiover/sleeper-picks-scraper').call({ leagues: ['NFL'], statTypes: ['Receiving Yards'], maxItems: 0 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

The run's key-value store holds a `SUMMARY` record next to the dataset: the outcome, rows saved by record type and league, lines on the whole board, players and games joined, request routes used, and the stat types on the board (`GET /v2/key-value-stores/<STORE_ID>/records/SUMMARY`).

### Input reference

| Input | Type | Default | What it does |
|---|---|---|---|
| `leagues` | array of text | empty = every league with lines | League codes: `NFL`, `CFB`, `NBA`, `WNBA`, `NHL`, `MLB`, `MMA`, `TENNIS`, `GOLF`, `CS2`, `EPL`, `LALIGA`, `SERIEA`, `BUNDESLIGA`, `LIGUE1`, `MLS`, or a family (`SOCCER`, `FOOTBALL`, `BASKETBALL`, `HOCKEY`, `ESPORTS`). Aliases `UFC`, `PGA`, `CS`, `NCAAF` work; so does Sleeper's raw code (`clubsoccer:epl`). Case does not matter. |
| `statTypes` | array of text | empty = all | Readable stat names (`Points`, `Passing Yards`) or Sleeper's keys (`pts_reb_ast`, `anytime_touchdowns`). Case, spaces and punctuation are ignored. |
| `playerNames` | array of text | empty = all | Partial names; accents and case ignored. |
| `teams` | array of text | empty = all | Team codes (`KC`, `LAL`) or, where available, names. Matches the player's team and either side of the matchup. |
| `side` | `both` / `over` / `under` | `both` | Keep one side only. Choosing one switches the output to one row per side. |
| `minMultiplier`, `maxMultiplier` | number | none | Keep sides paying at least / at most this multiplier (line rows: either side). |
| `minPickCount` | integer | none | Keep lines with at least this many picks in total. Lines without pick statistics are dropped when set. |
| `includePromos` | yes / no | yes | Add Sleeper's boosted and discounted promo lines (a handful) and flag them. |
| `onlyPromos` | yes / no | no | Only the promo lines. |
| `startsWithinHours` | integer 1–9,600 | none | Games starting within this many hours from now. |
| `startDateFrom`, `startDateTo` | `YYYY-MM-DD` | none | Games starting on or after / on or before this UTC day. |
| `rowShape` | `line` / `side` | `line` | One row per line with both sides in it (default), or one row per side (twice the rows). |
| `includeRecentGames` | yes / no | no | Add one row per past game in each line's history. Each is a billed result. |
| `maxItems` | integer 0–1,000,000 | 20,000 (prefill 100) | Rows saved at most; `0` = no limit. |
| `proxyConfiguration` | proxy | no proxy | Force a proxy for every request. Normally not needed. |

All filters combine with AND. Invalid values stop the run with `INVALID_INPUT` and a message that names the field.

### Data dictionary

Every column, with its type, meaning, the **measured fill rate** and an example from a real row. *Rows*: L = line rows (the default), S = side rows (`rowShape: side`), R = recent-game rows. Fill rates were measured over the 2026-10-29 proof run (6,734 side rows, 27,474 recent-game rows): both sides of a line carry the same line data, so every line-level column fills at the same rate on a line row; the over/under odds and probability columns are derived from the multipliers and fill whenever both multipliers do. Where a column is in both S and R the two rates are shown as *side / recent-game*. A fill rate below 100% is not a defect: the source does not carry the value for those rows (a golf line has no opponent, a tennis player no team, a line nobody picked no pick statistics).

#### Identity

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `rowId` | text · SLR | Unique key of the row | 100% / 100% | `sleeper:line:1421427865…` |
| `recordType` | text · SLR | `side`, `line` or `recentGame` (see Three kinds of rows) | 100% / 100% | `line` |
| `platform` | text · SLR | Always `sleeper` | 100% / 100% | `sleeper` |
| `projectionId` | text · SLR | The over side's line id, shared by both sides of a line | 100% / 100% | `1421427865261535255` |
| `lineKey` | text · SLR | `<sleeperSport>:<gameId>:<playerId>:<wagerType>` (+ round / promo suffix); pairs the sides | 100% / 100% | `nba:1393723788809469952…` |
| `marketType` | text · SL | Sleeper's own market string, for example `points_over_under_player_1240` | 100% | `points_over_under_playe…` |

#### Player

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `playerId` | text · SLR | Sleeper player id | 100% / 100% | `2299` |
| `playerName` | text · SLR | Full name from Sleeper's player catalogue | 100% / 100% | `Aaron Wiggins` |
| `playerTeam` | text · SLR | Team code (`GB`, `CLE`) or club name in soccer; empty in tennis, MMA, golf | 95.5% / 95.9% | `ATL` |
| `playerTeamName` | text · SL | Team nickname when the scoreboard carries one | 49.2% |  |
| `playerPosition` | text · SLR | Position on the line (`QB`, `WR`, `PG`, `C`, `D`) | 87.3% / 86.3% | `SF` |
| `positionRank` | text · SL | Rank within the team's position group, football only (`RB2`, `WR1`) | 27.5% |  |
| `jerseyNumber` | text · SL | Jersey number | 87.3% | `2` |
| `playerImageUrl` | text · SL | Sleeper headshot where one exists | 60.9% | `https://sleepercdn.com/…` |

#### Market

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `league` | text · SLR | `NFL`, `CFB`, `NBA`, `WNBA`, `NHL`, `MMA`, `TENNIS`, `GOLF`, `CS2`, `EPL`, `LALIGA` … | 100% / 100% | `NBA` |
| `sport` | text · SLR | Family: `football`, `basketball`, `hockey`, `soccer`, `mma`, `tennis`, `golf`, `esports` | 100% / 100% | `basketball` |
| `sleeperSport` | text · SLR | Sleeper's sport code (`nfl`, `nba`, `cs`, `clubsoccer:epl` …) | 100% / 100% | `nba` |
| `statType`, `statDisplayName` | text · SLR | Readable stat name (`Points`, `Pts + Rebs + Asts`, `Passing Yards`); the second column repeats it under the PrizePicks Scraper's name | 100% / 100% | `Points / Points` |
| `wagerType` | text · SLR | Sleeper's stat key (`points`, `pts_reb_ast`, `kills_maps_1_2` …) | 100% / 100% | `points` |
| `lineScore` | number · SLR | The over/under threshold (the line) | 100% / 100% | `11.5` |
| `round` | number · SL | Golf only: the tournament round the line is for | 1.2% |  |

#### Side & payout

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `side` | text · S | `over` or `under` | 100% | `over` |
| `lineId` | text · S | Sleeper's id of this side (globally unique) | 100% | `1421442837966237716` |
| `oppositeLineId` | text · S | Sleeper's id of the other side of the same line | 100% | `1421442837966237717` |
| `multiplier`, `oppositeMultiplier` | number · S | Payout multiplier of this side and of the other side | 100% | `1.95 / 1.64` |
| `oddsDecimal`, `oddsAmerican` | number · S | The multiplier read as decimal odds, and as American odds (1.78 is -128) | 100% | `1.95 / -105` |
| `impliedProbability`, `noVigProbability` | number · S | 1 / multiplier (break-even win rate), and the same with the margin removed so the pair sums to 1 | 100% | `0.5128 / 0.4568` |
| `overMultiplier`, `underMultiplier` | number · SL | Payout multiplier of each side (both row shapes) | 100% | `1.75 / 1.81` |
| `overLineId`, `underLineId` | text · SL | Sleeper line id of each side | 100% | `1421427865261535255 / 1…` |
| `overOddsAmerican`, `underOddsAmerican` | number · SL | Each side's multiplier as American odds (1.78 is -128); the decimal price is the multiplier | 100% | `-133 / -123` |
| `overImpliedProbability`, `underImpliedProbability` | number · SL | 1 / multiplier for each side: the break-even win rate | 100% | `0.5714 / 0.5525` |
| `overNoVigProbability`, `underNoVigProbability` | number · SL | Each side's implied probability with the margin removed (the pair sums to 1) | 100% | `0.5084 / 0.4916` |
| `marketOverround` | number · SL | Implied over + implied under - 1: the margin in the pair (about 0.12) | 100% | `0.1239` |

#### Promotion

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `lineType`, `oddsType` | text · SL | Sleeper's line type (`normal`, `line_promotion`) and the tier name (`standard`, `discount`, `boost`) | 100% | `normal / standard` |
| `isPromo`, `promotionType`, `displayAsFreePick` | yes/no · SL | Promotional-line flag, Sleeper's promotion label, and whether it is shown as a free pick | 100% / 0.1% / 0.1% | `False` |

#### Status & time

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `status` | text · SL | Line status at Sleeper (`active`) | 100% | `active` |
| `isLive` | yes/no · SL | True when the game has started | 100% | `False` |
| `gameStatus` | text · SL | Game state on the line: `pre_game` | 100% | `pre_game` |
| `startTime` | text · SLR | Game start, ISO-8601 UTC | 100% / 100% | `2026-10-30T00:00:00Z` |
| `updatedAt` | text · SL | When Sleeper last changed the line, ISO-8601 UTC | 100% | `2026-10-29T07:02:03.010Z` |
| `scrapedAt` | text · SLR | When the run built the row, ISO-8601 UTC | 100% / 100% | `2026-10-29T09:59:39.169Z` |

#### Game

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `gameId` | text · SLR | Sleeper game id (a number, `20261029_DAL_MTL` style, or `match-<n>`) | 100% / 100% | `1393723788809469952` |
| `gameWeek` | number · SL | Sleeper's week of the season (week of the year in individual sports) | 100% | `2` |
| `season` | text · SL | Season year | 100% | `2026` |
| `seasonType` | text · SL | `regular` or `post` | 100% | `regular` |
| `opponent` | text · SL | Opponent team code, or the other competitor in tennis and MMA | 98.8% | `CLE` |
| `isHome` | yes/no · SL | Player's side is the listed home slot (order is arbitrary in individual sports) | 98.8% | `True` |
| `homeTeam`, `awayTeam` | text · SL | Home and away team codes (club names in soccer without a code); the two competitors in tennis, MMA, CS2 | 98.8% | `ATL / CLE` |
| `homeTeamName`, `awayTeamName` | text · SL | Team nicknames where the scoreboard carries them | 60.7% |  |
| `homeTeamRecord`, `awayTeamRecord` | text · SL | Team records going into the game (`4-3-0`, `2-3`) | 87.3% | `2-3 / 3-1` |
| `matchup` | text · SL | `CAR @ GB` in team sports, `A vs B` in tennis, MMA, esports | 98.8% | `CLE @ ATL` |
| `venueName`, `venueCity`, `venueState`, `venueCountry` | text · SL | Venue name, city, state or province, and country | 87.3% / 87.3% / 85.8% / 87.3% | `State Farm Arena / Atla…` |
| `tvChannel` | text · SL | Broadcaster Sleeper lists for the game (`ESPN`, `AMZN`, `Peacock`) | 79.9% | `NBA TV` |
| `eventName` | text · SL | Event title (`Thursday Night Football`, `UFC Fight Night: …`) | 17.5% |  |
| `tournament` | text · SL | Tournament name (tennis and golf) | 3% |  |
| `matchType` | text · SL | Tennis match type (`women_singles`) | 1.8% |  |
| `weightClass` | text · SL | MMA weight class | 1.5% |  |
| `sportradarGameId`, `oddsjamFixtureId` | text · SL | Game / fixture ids at Sportradar and OddsJam, for joining other data | 88.2% / 36.6% | `8202c938-cdf3-4e4e-8f88…` |

#### Pick popularity

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `pickCount`, `pickShare` | number · S | Picks on this side, and its share of all picks on the line (0-1) | 58.8% | `6 / 0.6667` |
| `pickCountOver`, `pickCountUnder`, `pickCountTotal` | number · SL | Picks on the over, on the under, and in total | 58.8% | `214 / 8 / 222` |
| `pickShareOver`, `pickShareUnder` | number · SL | Over and under share of the picks (0-1) | 58.8% | `0.964 / 0.036` |
| `pickPopularity` | number · SL | Sleeper's own popularity score for the line (0-1, higher is more picked) | 58.8% | `0.9384` |

#### Recent form

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `recentGamesCount` | number · SLR | Number of past games in the line's history (up to 10) | 99.8% / 100% | `5` |
| `recentAverage` | number · SL | Average of the stat over those games | 99.8% | `14.6` |
| `recentOverCount`, `recentUnderCount`, `recentPushCount` | number · SL | Past games above, below and exactly on the current line | 99.8% | `4 / 1 / 0` |
| `recentHitRateOver`, `recentHitRateUnder` | number · SL | Those counts divided by the number of past games (4 decimals) | 99.8% | `0.8 / 0.2` |
| `recentHits`, `recentHitRate` | number · S | Past games this side would have won, and that divided by the games | 99.8% | `2 / 0.5` |
| `recentGames` | list · SL | The history itself, oldest first: `[{date, opponent, value}]` | 99.8% |  |

#### Player profile

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `playerAge` | number · SL | Age | 42.8% | `27` |
| `playerHeight`, `playerWeight` | text · SL | Height in inches and weight in pounds, as Sleeper stores them | 89.3% / 88.9% | `77 / 190` |
| `playerCollege`, `playerBirthDate`, `playerBirthCountry`, `playerYearsExp` | text · SL | College, birth date, birth country, years of experience | 37.4% / 62.3% / 4.6% / 85% | `Maryland / 1999-01-02 / 5` |
| `playerStatus` | text · SL | Roster status in Sleeper's catalogue (`Active`, `ACT`, `active`) | 90.3% | `ACT` |
| `injuryStatus`, `injuryBodyPart`, `injuryNotes` | text · SL | Injury designation (`Questionable`, `Out`, `IR`), body part and note; empty when healthy | 6.5% / 6.4% / 0.6% |  |
| `depthChartPosition`, `depthChartOrder` | text · SL | Depth chart slot and order (1 = starter) | 36.6% | `PF / 2` |
| `fantasyPositions` | list · SL | Positions the player is eligible for in fantasy formats | 39.9% |  |

#### External ids

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `sportradarId`, `espnId`, `yahooId`, `rotowireId`, `fantasyDataId`, `oddsjamId` | text · SL | Player ids at Sportradar, ESPN, Yahoo, Rotowire, FantasyData and OddsJam | 90.1% / 9.5% / 9.5% / 85.3% / 36.6% / 33.4% | `d3b28775-473d-471a-8452…` |

#### Recent-game rows

| Field | Type · rows | Meaning | Filled | Example |
|---|---|---|---:|---|
| `recentGameNumber` | number · R | Position of the game in the history, 1 = oldest | 100% | `4` |
| `pastGameDate`, `pastOpponent`, `pastValue` | text · R | Date, opponent and stat value of the past game | 100% / 96.3% / 100% | `2026-01-04 / DAL / 3` |
| `pastResult`, `pastMargin` | text · R | `over`, `under` or `push` against the current line, and the value minus the line | 100% | `over / 0.5` |

#### Which leagues fill which columns

`playerAge` is empty for hockey, college football, MMA and CS2 because Sleeper's catalogue carries no age for most of those players (hockey rows usually still have `playerBirthDate`); `oddsjamId` and `espnId` exist mainly for NFL and NBA players; `tvChannel` and `venueName` are published for most team-sport games but not for the individual sports; `opponent` is empty only in golf. Nothing is invented to fill a gap.

#### Conditional columns

These columns are empty on most rows by design; each one fills completely in the leagues where Sleeper publishes the value (measured in the proof run, share of rows within those leagues):

| Column | What it holds | Fills in (share within the league) | All rows |
|---|---|---|---:|
| `homeTeamName`, `awayTeamName` | team nicknames and club names (hockey, college football, soccer), the competitors' names in tennis, MMA and CS2 | `BUNDESLIGA`, `CFB`, `CS2`, `EPL`, `LALIGA`, `LIGUE1`, `MMA`, `NHL`, `SERIEA`, `TENNIS` (100%) | 60.7% |
| `playerTeamName` | the player's team nickname or club name where the scoreboard has one | `BUNDESLIGA`, `CFB`, `EPL`, `LALIGA`, `LIGUE1`, `NHL`, `SERIEA` (100%) | 49.2% |
| `matchType` | tennis match type (`women_singles`) | `TENNIS` (100%) | 1.8% |
| `playerBirthCountry` | players whose catalogue entry has a birth country (soccer, tennis, golf) | `BUNDESLIGA` 100%, `EPL` 94.4%, `GOLF` 100%, `LALIGA` 100%, `LIGUE1` 100%, `SERIEA` 100%, `TENNIS` 93.5% | 4.6% |
| `round` | golf: the tournament round of the line | `GOLF` (100%) | 1.2% |
| `tournament` | tennis and golf: the tournament name | `GOLF`, `TENNIS` (100%) | 3% |
| `weightClass` | MMA: the fight's weight class | `MMA` (100%) | 1.5% |

#### CSV columns

Line rows (the default) have 102 columns — every field marked *L* above. Side rows have 115: the same plus the per-side columns (`side`, `lineId`, `oppositeLineId`, `multiplier`, `oppositeMultiplier`, `oddsDecimal`, `oddsAmerican`, `impliedProbability`, `noVigProbability`, `pickCount`, `pickShare`, `recentHits`, `recentHitRate`). Recent-game rows have 26. A line row never carries empty per-side columns: the keys are simply absent. In a CSV export `recentGames` and `fantasyPositions` are JSON text inside the cell; in JSON they are real arrays.

#### How the numbers are computed

- **`overImpliedProbability`** = 1 ÷ `overMultiplier` to four decimals (the under twin likewise): 1.78 implies 0.5618, the win rate a single pick needs to break even. **`overNoVigProbability`** divides it by the sum for both sides, so the pair adds to 1; **`marketOverround`** is that sum minus 1 (median 0.1237 in the proof run, range 0.0653 to 0.1594). On side rows the same numbers for the row's own side are `impliedProbability` and `noVigProbability`.
- **`overOddsAmerican`** converts the multiplier as a decimal price: 1.78 is −128, 2.36 is +136, 3.5 is +250. The decimal price is the multiplier itself.
- **`pickShareOver`** = picks on the over ÷ all picks on the line. **`recentOverCount`** counts past games strictly above `lineScore`, **`recentUnderCount`** strictly below, **`recentPushCount`** exactly on it; hit rates divide by the past games, so ties lower both. **`recentAverage`** is the mean of the listed games.

These convert numbers Sleeper publishes. A multiplier is a pick'em payout factor; reading it as a decimal price is a convenience for comparison with sportsbook odds, not a statement about how Sleeper settles an entry — how picks combine into an entry payout is Sleeper's own rule, which this Actor neither reads nor reproduces.

### Scale, speed and measurements

All numbers below were measured on the Apify platform on **2026-10-29** with the default 1,024 MB memory setting.

| Run | Input | Result |
|---|---|---|
| Console prefill | `{"maxItems": 100}` (one row per line, the default) | 100 rows, finished in 2.7 s, first row after 1.4 s |
| 1,000 lines | `{"maxItems": 1000}` | 1,000 rows in 3 s |
| The whole board, one row per side | `{"rowShape": "side", "maxItems": 0}` | 6,734 rows in 9.2 s (the default shape writes half as many rows) |
| Proof run | `{"rowShape": "side", "maxItems": 0, "includeRecentGames": true}` | **34,208 rows, 34,208 unique `rowId`s, 0 duplicates**, 21.2 s (6,734 side rows + 27,474 recent-game rows) |

**Which shape the proof used.** The ≥10,000-row proof ran with `rowShape: side` and `includeRecentGames: true` on build 1.0.4, the final extraction code. Later builds changed only the default row shape (now one row per line), added the over/under American-odds and probability columns, the budget-stop message and this README; the fetching and joining are unchanged.

**Why the proof run adds recent-game rows.** The whole public board is smaller than 10,000 rows: 3,367 lines are 6,734 sides on 2026-10-29, and the Actor returns every line and side on it. Each line also carries up to ten past games, and `includeRecentGames` writes each as its own row — real data, which is how one run reaches 34,208 rows. Without it, expect the board's own size: 3,367 rows by default, 6,734 with `rowShape: side`.

A run makes about 40–60 small requests (the board and the promo board, then per sport the player catalogue, the current week and its scoreboard), almost all straight from the platform. The board is one cached JSON of about 5.7 MB (390 KB compressed). Most of the time goes into writing rows; the Actor writes in batches as soon as the data is joined and stops cleanly at a time or cost limit.

Connection, measured on 2026-10-29: Sleeper's public endpoints answered a direct connection from the platform, the Apify datacenter proxy, a US residential exit and a laptop in Turkey; no geographic block was seen. The Actor goes direct first, retries once, then uses the datacenter proxy, and at most eight residential requests per run as a last resort. A run that cannot read the board fails with `BLOCKED` or `FETCH_FAILED`; it never reports an empty result for an access problem.

### What you pay

Pay per result. Every row written to the dataset is one result — by default one line, one prop. There is no start fee and no charge for the summary record.

| Plan | Price per 1,000 rows |
|---|---:|
| Free | $0.25 |
| Bronze | $0.217 |
| Silver | $0.183 |
| Gold, Platinum, Diamond | $0.15 |

| Rows | Free plan | Gold plan and above |
|---|---:|---:|
| 1,000 | $0.25 | $0.15 |
| 10,000 | $2.50 | $1.50 |
| 100,000 | $25.00 | $15.00 |

Today's whole board in the default shape (3,367 lines, 3,367 rows) costs about $0.84 on the Free plan and about $0.51 on Gold and above. `rowShape: side` doubles the rows (6,734: about $1.68 and $1.01), and `leagues`, `startsWithinHours` or `minPickCount` shrink it. Optional recent-game rows are billed like any other row — leave them off unless you want the flat game-log table.

**Maximum cost per run.** Apify lets you set a spending ceiling on every run of a pay-per-result Actor (run options, "Maximum cost per run"). The Actor reads it before it writes anything and never writes past it: the dataset ends exactly at what the ceiling pays for, the run finishes as *succeeded*, and the status message says so — for example "Saved 230 rows — this run's maximum cost ($0.05) covers 230 results at the current price. Raise "Maximum cost per run" to get more." (the number depends on your plan's price per result: $0.05 buys 200 rows on the Free plan). Rows already written are kept and billed; nothing is written and then cut. If the ceiling covers no result at all the run says that too.

### Integrations and scheduling

- **Schedules.** In the Console, *Schedules* runs the Actor on a cron: daily for a morning board, hourly for movement, every few minutes on game day. Sleeper's edge cache holds the board for about 30 seconds (the response header says `s-maxage=30`), so polling faster than every minute mostly re-reads the same snapshot.
- **Webhooks.** A webhook on `ACTOR.RUN.SUCCEEDED` can call your endpoint with `{"runId": "{{resource.id}}", "datasetId": "{{resource.defaultDatasetId}}"}`; fetch `datasets/<id>/items` from there.
- **Google Sheets.** The Apify integration appends a finished run's dataset to a sheet; point it at the *Board* columns or use `fields=` in the dataset URL to keep it narrow.
- **Airtable, Make, Zapier, n8n.** Use the *Run Actor* module, then *Get dataset items*. Filter on `isPromo`, `pickShareOver` or `overOddsAmerican` inside the scenario, or push the filters into the Actor's input so you pay for fewer rows.
- **BigQuery, Snowflake, Postgres.** Export JSON or CSV from the dataset API on a schedule and load it; the dataset schema is typed, every column is nullable, and `rowId` is the primary key. For history, append rows and keep `scrapedAt`.
- **MCP and AI agents.** Apify's MCP server exposes any Actor as a tool; give an assistant `logiover/sleeper-picks-scraper` with a narrow input (`leagues`, `startsWithinHours`, `maxItems`) so answers come from live data.
- **Line-movement archive.** Schedule a run, append to a table, and compare consecutive snapshots on `lineKey`: a change in `lineScore` is a moved line, a change in a multiplier is a repriced side, a new `lineKey` is a new line, a missing one is a pulled line. The Actor does not keep history for you — your schedule does, and the dated rows (`scrapedAt`, `updatedAt`) make the table self-explanatory.

### Performance tips

1. Ask only for what you need: `leagues`, `startsWithinHours` and `minPickCount` cut rows before they are billed, and the default one-row-per-line shape is already half of `rowShape: side`.
2. Leave `includeRecentGames` off unless you want the flat game-log table; the same history is in the `recentGames` column of every normal row.
3. Do not poll faster than once a minute, and leave the proxy empty: the direct route was the fastest in every measurement.
4. Key on `projectionId` (lines) or `lineId` (sides) when you de-duplicate or diff runs, and set **Maximum cost per run** while you experiment.

### Troubleshooting

The Actor ends with one of these outcomes in the status line and in the `SUMMARY` record.

| Message (starts with) | Meaning | What to do |
|---|---|---|
| `COMPLETED: saved N rows …` | Normal finish. May continue with "the maxItems limit of N was reached" or "this run's maximum cost of $X covers N results". | Raise `maxItems` / the cost ceiling if you wanted more. |
| `PARTIAL: saved N rows …` | Rows were saved, but the time limit was reached, or a player catalogue / scoreboard request failed ("no names for those rows", "no start times for those rows"). | Run again; the board is public and the failure is usually momentary. |
| `EMPTY_RESULT: Sleeper has no lines posted for … right now` | The league you asked for has no lines (off-season, or no games soon). | Leave `leagues` empty to see every league, or try later. |
| `EMPTY_RESULT: Sleeper Picks has no lines on the board right now` | The whole board is empty. | Try later. |
| `EMPTY_RESULT: the board has N lines in … but none match these filters` | Your filters exclude everything. The message lists leagues and stat types that exist. | Loosen a filter; check spelling of a player or stat. |
| `INVALID_INPUT: …` | A value is out of range or malformed; the message names the field (`rowShape`, `maxItems`, `minMultiplier`, `maxMultiplier`, `minPickCount`, `startsWithinHours`, `startDateFrom`, `startDateTo`). | Fix the field. |
| `BLOCKED: no board collected …` / `FETCH_FAILED: no board collected …` | The board could not be read after the retries (an access problem or a network failure — never an empty result). | Run again; set a proxy in the input if the failure repeats. |
| "does not cover a single result" | The maximum cost per run is lower than the price of one row. | Raise it. |

`SUMMARY.notes` records anything partial: players missing from Sleeper's catalogue (no name or profile), games missing from the scoreboard (no start time or venue), an unreadable promo board, a restart that resumed an earlier run, a `side` filter that switched the shape, and cross-section sampling when a limit cut the board.

### Honest limits

- **A snapshot, not a tape.** Each run returns the board as it is now: no tick history, no settled results. Schedule runs to build your own history.
- **Pre-game only.** Every line on the board was pre-game on 2026-10-29; Sleeper removes lines when games start, and there is no in-game feed.
- **One line per player, stat and game.** Sleeper's public board carried no alternate-line ladders on 2026-10-29: apart from a handful of promos there is one line per player, stat and game. If Sleeper adds alternates, the Actor passes them through as extra lines, because it keeps every line the board lists.
- **Pick statistics are partial.** 58.8% of side rows had pick counts; Sleeper publishes none for a line nobody has picked. The 0–1 popularity score is Sleeper's own number and its formula is not published.
- **The board follows the calendar.** MLB is dark in the off-season and soccer markets arrive near kick-off; a league with nothing posted returns nothing, and that is reported, not an error.
- **Individual sports have no team.** Tennis, MMA and golf rows have no team, venue or TV channel; `homeTeam` / `awayTeam` hold the two competitors in Sleeper's order. Names are Sleeper's spelling; use the external ids to join other sources.
- **Multipliers are not sportsbook odds.** `oddsDecimal`, `oddsAmerican` and `impliedProbability` are arithmetic on Sleeper's multiplier — useful for comparison and modelling, not a statement of how any entry is paid.
- **Availability differs by place.** The public board is the same for everyone who can read it; whether you may play Sleeper Picks or use betting data in your country is a legal question this Actor does not decide.

### Comparison with the other ways to get this data

| Way | Good for | Falls short |
|---|---|---|
| Looking in the Sleeper app | One player, right now | No export, no history, no cross-league filters |
| Sleeper's documented API | Leagues, rosters, drafts, players | Built for fantasy leagues; as far as we can tell it does not document the Picks board |
| Your own script on the public JSON | Full control | You must join four sources, handle sport-code quirks (soccer competitions, split-year seasons, leagues whose "current week" lags), keep it running and fix it when fields change |
| **This Actor** | The board as clean, joined, documented rows on demand or on a schedule | Snapshot only, pre-game only; what Sleeper does not publish is not there |

### Frequently asked questions

#### Is there a Sleeper Picks API?

Sleeper documents an API for fantasy leagues, rosters and drafts, but as far as we can tell not the Picks board. The board is public JSON that Sleeper's own apps read without a login; this Actor returns it as clean rows — a Sleeper Picks API without a key or scraping code.

#### How do I scrape Sleeper Picks player props?

Run the Actor with `{"maxItems": 0}` for every league on the board, or add `leagues`, `playerNames` or `statTypes`. Each row is one line (one prop) with both payout multipliers, odds, pick counts, recent form and injury status. Export JSON, CSV or Excel.

#### Do I need a Sleeper account, token or login?

No. The Actor reads only what any visitor or app user can see; it never logs in and never places a pick.

#### Which sports and leagues does it cover?

Whatever Sleeper has lines for: NFL, college football, NBA, WNBA, NHL, MMA, tennis, golf, CS2 and, when posted, soccer (EPL, La Liga, Serie A, Bundesliga, Ligue 1, MLS) and MLB — 14 leagues on 2026-10-29. A league with no lines returns nothing and the status message says so.

#### What is a payout multiplier on Sleeper Picks?

The factor Sleeper posts for a side of a line; a 1.78 side pays 1.78 times the stake when played on its own and wins. How several picks combine into an entry payout is defined by Sleeper's rules, not by this Actor.

#### How do I turn a Sleeper multiplier into implied probability?

Divide 1 by the multiplier — `overImpliedProbability` and `underImpliedProbability` do it to four decimals, and the `NoVig` twins remove the margin so the two sides sum to 1. A 1.78 / 1.78 line implies 0.5618 each, a 12% overround.

#### What is the difference between line rows and side rows?

A line row (the default) holds the over and the under of one prop side by side: `overMultiplier` / `underMultiplier`, the American odds, probabilities and pick counts of both. A side row (`rowShape: side`) is the over or the under on its own with its own Sleeper id (`lineId`) and costs twice as much, because there are two per line.

#### What does `pickPopularity` mean, and why is it sometimes empty?

It is Sleeper's own 0–1 popularity score; how it is computed is not published. Sleeper attaches pick statistics only to lines that have been picked — 58.8% of side rows on 2026-10-29 — so empty means "none published", not zero. For exact crowd behaviour use the counts and shares.

#### How often do Sleeper lines change?

Every few minutes on a busy day (`updatedAt` shows the last change). Sleeper's edge cache serves a board for about 30 seconds, so scheduling faster than once a minute re-reads the same snapshot.

#### Does it include alternate lines?

Not on 2026-10-29: Sleeper's public board carried one line per player, stat and game plus a handful of promos. The Actor keeps every line the board lists, so alternates would appear as extra lines with their own `lineId` and `lineScore` if Sleeper published them.

#### What are promo, boosted and discounted lines?

A few promotional lines Sleeper posts: a discounted threshold (`oddsType: discount`, often a free pick) or a boosted multiplier (`oddsType: boost`). They are flagged with `isPromo`, `promotionType` and `displayAsFreePick`; `onlyPromos` returns just those.

#### Does it include live, in-game lines?

No. Every line on the board was pre-game on 2026-10-29; Sleeper removes lines when a game starts. `isLive` and `gameStatus` are on every row in case that changes.

#### Can I get historical Sleeper lines, line movement or closing line value?

Sleeper keeps no history on the public board. Schedule the Actor, append each run to a table keyed by `lineKey` and `scrapedAt`, and compare snapshots: a changed `lineScore` is a moved line, a changed multiplier a repriced side, and the last snapshot before `startTime` is your closing line.

#### Can I compare Sleeper with PrizePicks, Underdog or sportsbook odds?

Yes — the column names follow the PrizePicks Scraper, and `sportradarId`, `oddsjamId`, `sportradarGameId` and `oddsjamFixtureId` identify the same player and game in other sources. A pick'em multiplier is not a sportsbook price, so convert with care.

#### Is there arbitrage or +EV between Sleeper and sportsbooks?

Pick'em lines and sportsbook props have different payout rules, so a gap between a Sleeper implied probability and a book's no-vig price is a research signal, not a guaranteed profit. The Actor supplies clean inputs (`overNoVigProbability`, `recentHitRateOver`); estimating the true probability is your model's job.

#### How do I find the most picked players tonight?

`{"startsWithinHours": 24, "minPickCount": 100, "maxItems": 0}`, then sort the dataset by `pickCountTotal` or `pickShareOver`.

#### How do I filter by player, team or stat?

`playerNames`, `teams` and `statTypes` are lists. Names ignore case and accents and match partial text; teams match by code (and by name where Sleeper lists one) on either side of the matchup; stats match the readable name or Sleeper's key.

#### Why does my player filter return nothing?

The player probably has no line on the board right now (injured, resting, not in a covered game), or the name is spelled differently — try the surname. The status message lists the leagues and stat types the board has.

#### What do `wagerType` and `statType` mean?

`wagerType` is Sleeper's key (`pts_reb_ast`, `kills_maps_1_2`); `statType` is the readable label (`Pts + Rebs + Asts`, `Kills (Maps 1+2)`). A new Sleeper stat appears under a readable version of its key until a label is added.

#### What do `gameWeek` and `isHome` mean?

`gameWeek` is Sleeper's week number for the game (week of the season in football, the week of the year in tennis, golf, MMA and CS2). `isHome` says which slot the player occupies; in individual sports and esports the home/away order carries no meaning.

#### Why do tennis, MMA and golf rows have no team or venue?

They are individual sports: Sleeper has no team and, for most events, no venue or TV channel. The columns stay empty rather than guessed; tournament, event name and weight class are filled where Sleeper gives them.

#### How do I get the player's recent games?

Every normal row has `recentGames` (date, opponent, value; up to ten) for that exact stat, plus the average, over/under/push counts and hit rates. `includeRecentGames` writes each past game as its own row instead.

#### Does it give injury information and headshots?

Injury status, body part, note and depth chart come from Sleeper's player catalogue; most players have none (436 of 6,734 side rows in the proof run carried a status). `playerImageUrl` is Sleeper's headshot for NFL, NBA, WNBA, NHL, tennis and MMA players; other sports have no image.

#### How much does a full run cost, and how do I cap it?

The whole board in the default shape is 3,367 rows: about $0.84 on the Free plan and $0.51 on Gold and above ($0.25 / $0.15 per 1,000 rows); `rowShape: side` doubles it. Set **Maximum cost per run** in the run options: the Actor writes only what the ceiling pays for, finishes successfully and says so.

#### Can I run it from outside the US?

Yes. It runs on the Apify platform, and the endpoints also answered from Turkey without a geographic block. Whether you may play Sleeper Picks or use betting data where you live is a separate legal question.

#### Is it legal to scrape Sleeper Picks?

The Actor reads public data served to every visitor, without logging in or bypassing any access control. Whether a particular use is permitted depends on Sleeper's terms, your jurisdiction and your purpose — see the legal chapter; you are responsible for your own compliance.

#### Can I use the data to place picks automatically?

No. The Actor never logs in to Sleeper and cannot place, change or cancel a pick; it supplies data for research.

#### Which export formats and integrations work?

JSON, CSV, Excel, XML, RSS and HTML from the dataset's Export menu or the API; Google Sheets, Airtable, n8n, Make, Zapier, webhooks and Apify's MCP server for AI assistants.

#### How do I avoid duplicates between runs?

Use `rowId` (or `projectionId` for lines, `lineId` for sides). A line keeps its Sleeper id while it is on the board; if Sleeper reprices a side the id stays and the multiplier changes — that is how you detect movement.

#### What happens if Sleeper changes something?

Unknown stats appear under a readable version of their key, unknown leagues under their uppercase code, and a missing player or game leaves dependent columns empty and is reported in the summary. If Sleeper restructures an endpoint, runs fail with a clear message rather than return wrong data, and we update the Actor.

#### Who do I contact about a bug or a missing column?

Open an issue on the Actor's page or message us — we reply within 24 hours.

### Glossary

- **Pick'em** — picking the over or under on player stat lines instead of betting at fixed odds.
- **Line / side** — a player, a stat and a game with a threshold (*Points 11.5*); each line has an **over** side and an **under** side, with its own Sleeper id and multiplier. Landing exactly on the threshold is a **push**.
- **Payout multiplier** — the factor Sleeper posts for a side. **Implied probability** — 1 ÷ multiplier, the win rate that breaks even. **No-vig probability** — that, with the margin removed. **Overround (vig, hold)** — the margin: the implied probabilities' sum minus 1.
- **Hit rate** — the share of recent games that cleared a threshold. **Pick count / share** — how many users picked a side and its share of the line's picks. **Popularity score** — Sleeper's own 0–1 ranking number.
- **Promo, boost, discount, free pick** — Sleeper's promotional lines: a raised multiplier, or a lowered threshold shown at no cost.
- **Wager type** — Sleeper's key for the stat (`passing_yards`). **Board** — all lines open at a moment.
- **Line shopping, line movement, closing line value, +EV, arbitrage** — comparing a prop across platforms; how a line changes after you take it; how your number compares with the last one before the game; a pick whose true win probability beats its break-even; locking a profit across opposite sides (rarely clean between a pick'em platform and a sportsbook).
- **DTD / GTD / IR / Questionable / Out / Doubtful** — injury designations. **Depth chart order** — rank at the position (1 = starter).
- **rowId, projectionId, lineKey** — this Actor's unique row key; the over side's id shared by both sides of a line; the market key that pairs the sides.

### 🤖 AI Agents, MCP & RAG Integration

**Sleeper Picks Scraper** works natively as an on-demand data tool for AI assistants and autonomous workflows.

Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=logiover/sleeper-picks-scraper"
    }
  }
}
```

- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.

### Legal and responsible use

**What the Actor does.** It reads public data Sleeper serves to every visitor and app user: the open board, the promo board, the scoreboard and the player catalogue. It does not log in, use any account, bypass a paywall or access control, or collect personal data about Sleeper's users (pick counts are aggregates), and it does not place, change or cancel picks. It makes a few dozen requests per run.

**What you are responsible for.** Terms of service, gambling and data laws differ by country and state; Sleeper Picks itself is not available everywhere. Whether you may use this data, for what, and how you store or redistribute it is your decision and responsibility; this is not legal advice. If your pipeline handles personal data, GDPR, CCPA and similar rules apply to you.

**Use it for analysis.** Research, modelling, journalism, comparison, education, monitoring. The Actor is not a tip service: nothing here predicts outcomes, no strategy built on the data is guaranteed to win, and past games in `recentGames` are not forecasts. Never stake money you cannot afford to lose. If gambling stops being fun, contact your country's problem-gambling helpline and use the limits and self-exclusion tools your platform offers. The Actor is independent, carries no affiliate links and promotes no operator.

### Changelog

**2026-11-14.** Verified live production health run (2026-11-14): extracted **35** structured records in **3.8s** with valid schema output. Hardened internal proxy stall fallback and pay-per-event dataset instance budget protection.

**2026-11-11.** Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration. Added direct Issues & Reviews support links and refreshed live maintenance verification.

**2026-11-01.** Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.

**1.0 — 2026-10-29.** First release. The live Sleeper Picks board with one row per line — the over and the under side by side, like a one-row-per-prop table — with multipliers, American odds, implied and no-vig probabilities, pick counts and popularity, recent form and hit rates, injury and profile columns, matchup, venue, TV channel and start time, and promo flags. `rowShape: side` writes one row per side instead (choosing a `side` filter switches to it), and `includeRecentGames` adds one row per past game. Filters for league, stat, player, team, side, multiplier, pick count and start window; soccer competitions, split-year seasons and promo twins handled; pay per result with a maximum-cost guard; direct connection first with a datacenter and a capped residential rescue; a `SUMMARY` record with the outcome and counts.

### 💬 Support, Issues & Reviews

A missing field, a stat label you would like, a league that behaves oddly: open an issue on the Actor page or send a message — **we reply within 24 hours.** Include the run id and, if you can, the input; the `SUMMARY` record in the run's key-value store usually tells us the rest.

- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/sleeper-picks-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/sleeper-picks-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/sleeper-picks-scraper/reviews) or bookmarking [logiover/sleeper-picks-scraper](https://apify.com/logiover/sleeper-picks-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/sleeper-picks-scraper/changelog.md

# Actor input Schema

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

League codes to read: `NFL`, `CFB`, `NBA`, `WNBA`, `NHL`, `MLB`, `MMA` (UFC), `TENNIS`, `GOLF`, `CS2`, and the soccer leagues (`EPL`, `LALIGA`, `SERIEA`, `BUNDESLIGA`, `LIGUE1`, `MLS`, or `SOCCER` for all of them). Pick from the list or type any code Sleeper uses (`cs`, `ufc`, `pga`, `clubsoccer:epl` also work); codes are not case-sensitive. Leave empty to read every league that has lines right now. A league with no lines posted (off-season) simply returns nothing.

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

Keep only these stats: `Points`, `Rebounds`, `Passing Yards`, `Anytime Touchdowns`, `Shots on Goal`, `Kills (Maps 1+2)` … Case-insensitive; matches the readable name (`statType`) or Sleeper's key (`wagerType`, e.g. `pts_reb_ast`). The run summary lists every stat on the board.

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

Keep only these players. Case-insensitive, accents ignored, partial names allowed (`Jokic` finds Jokić, `Lamar` finds Lamar Jackson).

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

Keep only props of these teams or of games involving them: team code (`KC`, `GB`, `LAL`) or, where Sleeper lists one, the team name (`Blue Jackets`, `Fulham`). Matches the player's team and either side of the matchup.

## `side` (type: `string`):

Keep only the over or only the under. Choosing one switches the output to one row per side (a row per line cannot hold just one side).

## `minMultiplier` (type: `number`):

Keep only sides paying at least this multiplier, e.g. `2.5` for the long shots. Leave empty for no limit.

## `maxMultiplier` (type: `number`):

Keep only sides paying at most this multiplier, e.g. `1.6` for the heavy favourites. Leave empty for no limit.

## `minPickCount` (type: `integer`):

Keep only lines Sleeper users have picked at least this many times (over + under), e.g. `100` for the crowd favourites. Lines without pick statistics are dropped when this is set.

## `includePromos` (type: `boolean`):

Sleeper posts a few boosted and discounted lines on a separate promo board. On = they are added and flagged (`isPromo`); off = the regular board only.

## `onlyPromos` (type: `boolean`):

Keep only the boosted and discounted lines (a handful at a time).

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

Keep only games that start within this many hours from now (e.g. `24` for today's board). Leave empty for no limit.

## `startDateFrom` (type: `string`):

Keep only games starting on or after this day, `YYYY-MM-DD` (UTC).

## `startDateTo` (type: `string`):

Keep only games starting on or before this day, `YYYY-MM-DD` (UTC).

## `rowShape` (type: `string`):

A Sleeper line has an over side and an under side, each with its own line id and payout multiplier. `line` (default) writes one row per prop with both sides in it (multipliers, odds, probabilities, pick counts); `side` writes one row for each side, which is twice the rows. Every row is one billed result.

## `includeRecentGames` (type: `boolean`):

Also write one extra row for every past game in each line's recent-performance history (up to 10 per line: date, opponent, value, over/under/push against the current line). Every such row is a billed result; the history is also on each main row as `recentGames` at no extra cost.

## `maxItems` (type: `integer`):

Upper bound on rows saved (each row is one billed result). The whole board is about 3,400 lines (rows) today, about 6,800 with one row per side, about 31,000 with recent-game rows on top. Set `0` for no limit. Rows come in board order: league, then soonest game first.

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

Optional. By default the Actor connects directly and falls back to the Apify datacenter proxy and, as a last resort, a capped US residential exit by itself. Set a proxy here only if you want every request to go through it.

## Actor input object example

```json
{
  "leagues": [],
  "statTypes": [],
  "playerNames": [],
  "teams": [],
  "side": "both",
  "includePromos": true,
  "onlyPromos": false,
  "rowShape": "line",
  "includeRecentGames": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All Sleeper Picks rows collected in this run.

# 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": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/sleeper-picks-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": [],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/sleeper-picks-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": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/sleeper-picks-scraper --silent --output-dataset

```

## MCP server setup

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