# DraftKings Scraper - Sports Odds, Results, DFS & Player Props (`abotapi/draftkings-sportsbook-odds-scraper`) Actor

Scrape DraftKings Sportsbook odds, game lines, team totals, player and game props, futures, Pick6 multipliers and final scores. Extract DFS contests, entry fees, prize pools, player salaries and stats. Includes nested markets with American, decimal and fractional odds.

- **URL**: https://apify.com/abotapi/draftkings-sportsbook-odds-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 board, contest or player records

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

## DraftKings Sportsbook Odds Scraper

Scrape DraftKings Sportsbook: the odds board (game lines, team totals, player props, award futures, game props), Pick6 multipliers, and the DFS surface (contests with fees and prize pools, plus player lists with salaries, positions and stats), and the final scores of past games (who won and by how much). One board row per game carries the flattened main lines and the full nested market odds in American, decimal and fractional formats.

### Why This Scraper?

- **The whole board, one row per game.** Every record carries the moneyline pair, spread line and odds, and total line and odds flattened on the row, plus the complete nested market list with every selection's price in all three odds formats.
- **Superset scope in one actor.** Sportsbook odds, the player-prop menu, award outright futures, Pick6 multipliers, and the DFS contests-and-salaries surface are collected by one run instead of four different tools.
- **Every league on the book.** The run resolves the site's own live catalog, so any sport page slug and any league slug on the book is reachable, not a hardcoded list.
- **Built for line watching.** Incremental mode fingerprints every odds value, so a scheduled run classifies exactly which games and markets moved, with per-field change lists.
- **URL mode for precision.** Paste a sport page, a league page, a game page, or an NBA, NFL, MLB or NHL player-props or futures page and the actor reads exactly that surface.
- **State-aware.** Pick a state token to read that state's regional view of the book.
- **Results, not just prices.** Turn on final scores and the same run returns every finished game of the last days in your leagues with the final score, the winner and the venue, linked to the game's odds event id wherever the book publishes it.

### Use Cases

- **Line movers and model builders:** pull every game's current prices across leagues on a schedule and diff the nested odds against yesterday's baseline.
- **Prop-market researchers:** harvest the full player-prop menu (points, rebounds, assists, combos, milestones, races) per league with all selection prices.
- **DFS players:** collect the contest lobby (entry fees, prize pools, guarantees, entry counts) plus player salaries, positions and stat rows for lineup building.
- **Odds aggregators:** mirror the book's board per state region into your own store or spreadsheet via the dataset export or MCP connectors.
- **Futures watchers:** track award outright prices (MVP, Rookie of the Year, and more) as the season moves.
- **Bet graders and model backtests:** pair yesterday's closing lines with the final scores from the same actor to grade picks and measure model accuracy.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `kind` | event |
| `recordId` | event:00000000 |
| `name` | Home Team @ Away Team |
| `sportName` | Basketball |
| `leagueName` | League One |
| `startTime` | 2027-01-01T00:00:00Z |
| `status` | NOT_STARTED |
| `homeTeam` | Home Team |
| `homeTeamAbbr` | HT |
| `awayTeam` | Away Team |
| `awayTeamAbbr` | AT |
| `homeMoneylineAmerican` | -110 |
| `awayMoneylineAmerican` | -110 |
| `spreadLine` | 2.5 |
| `spreadHomeAmerican` | -108 |
| `spreadAwayAmerican` | -112 |
| `totalLine` | 210.5 |
| `overAmerican` | -108 |
| `underAmerican` | -112 |
| `marketGroupLabel` | Game lines (moneyline, spread, total) |
| `subcategoryLabel` | Game Lines |
| `url` | https://sportsbook.draftkings.com/event/sample-game/00000000 |
| `detailFetched` | true |
| `capturedAt` | 2027-01-01T00:00:00Z |

Every board row also carries `markets`: the full nested list of markets for the selected group, each with its selections (`label`, `points`, `oddsAmerican`, `oddsDecimal`, `oddsFractional`, `impliedProbability`, `trueOdds`, participant names and ids). With **Final scores of past games** on, finished games arrive as `result` rows (one per game): `homeTeam`, `awayTeam`, integer `homeScore` and `awayScore`, `winner` (`home`, `away` or `draw`), `winnerTeam`, `statusDetail` (for example `Final/OT`), `venue`, `startTime`, the odds `eventId` where it can be linked (else empty, with a `matchKey` of league, date and teams for your own join), and per-sport extras (`attendance`, `broadcast`, `weekNumber`, `seasonName`, the winning and losing pitcher for baseball, the three stars for hockey). Covered leagues: NFL, NBA, MLB, NHL, college football, college basketball (men), and the major soccer leagues and cups (Premier League, LaLiga, Bundesliga, Serie A, Ligue 1, MLS, Liga MX, Champions League, Europa League and more); other leagues on the board have no results surface and are named in the log. Only finished games are returned: games not started, postponed or still in play never produce a result row. `winner` compares the final scores only, so a knockout cup game level after extra time and decided on penalties shows `draw`. DFS runs push two further record kinds: `dfs_contest` (contest id, name, entry fee, max entries, entries, prize pool, top payout, draft group, start time, guaranteed flag) and `dfs_player` (player id, name, position, salary, status, team, stat rows, competition ids, images).

### How to Use

1. Add the Actor in Apify Console.
2. Keep search mode with the default sport, or name your sports and leagues (site slugs such as `basketball` or `basketball/nba`).
3. Pick the market groups you want; game lines is the default.
4. Run and export the dataset, or schedule it with incremental mode to track line moves.

#### Example: NBA game lines

**Search the NBA game lines:**

```json
{
    "mode": "search",
    "sportSlugs": ["basketball"],
    "leagues": ["nba"],
    "marketGroups": ["game-lines"],
    "maxItems": 20
}
```

#### Example: player props

**Read player props and team totals:**

```json
{
    "mode": "search",
    "sportSlugs": ["basketball"],
    "leagues": ["nba"],
    "marketGroups": ["player-props", "team-totals"],
    "maxItems": 50
}
```

#### Example: pasted links

**Scrape pasted links:**

```json
{
    "mode": "url",
    "urls": [
        { "url": "https://sportsbook.draftkings.com/leagues/basketball/nba" },
        { "url": "https://sportsbook.draftkings.com/page/nba-player-props" }
    ],
    "maxItems": 40
}
```

#### Example: odds, DFS and final scores in one run

**Add the DFS surface and the last three days' final scores:**

```json
{
    "mode": "search",
    "sportSlugs": ["basketball"],
    "leagues": ["nba"],
    "marketGroups": ["game-lines"],
    "includeDfs": true,
    "dfsSport": "basketball",
    "includeResults": true,
    "resultsDaysBack": 3,
    "maxItems": 200
}
```

#### Run it from your code

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("abotapi/draftkings-sportsbook-odds-scraper").call(run_input={
    "mode": "search",
    "sportSlugs": ["basketball"],
    "leagues": ["nba"],
    "marketGroups": ["game-lines"],
    "maxItems": 20,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('abotapi/draftkings-sportsbook-odds-scraper').call({
    mode: 'search',
    sportSlugs: ['basketball'],
    leagues: ['nba'],
    marketGroups: ['game-lines'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Tips

- **Scheduled line watching:** enable incremental mode on a daily schedule; UNCHANGED rows are suppressed by default and UPDATED rows name the fields that moved (`changedFields`).
- **Cheapest full menu:** `game-lines` alone is one read per league; each extra market group adds its own section reads per league (team totals and game props one each, futures six, player props sixteen).
- **State view:** the default board is the national view; pick a state token to read that region's view.
- **DFS scope:** the DFS surface reads the contest lobby plus up to four draft groups' player lists per run, capped by Max items.
- **Results and Max items:** with final scores on, the scores are read first and up to half of Max items is kept for the result rows that will really be delivered (new or changed ones); when there are none, the board keeps the whole cap, and results also use whatever the board leaves. Raise Max items (or set 0) for full boards plus full results.
- **NBA results:** NBA scores are found by walking the book's fantasy slates, so the first NBA results run reads more pages than later ones: measured locally, about 90 page reads and two minutes for a 2-day window, about 220 reads and six minutes for 7 days (a 14-day first run can reach the per-run read bound, and the status message then says part of the window was not reached). A scheduled run picks up only the games finished since the last run. A game that is not yet final on the score pages is collected by a later run.
- **Run time limit:** final-score reads stop when less than about 90 seconds of the run's time limit are left, so the odds board keeps its time; the status message then says the scores were cut by the run's time limit.

### Send results into your apps (MCP connectors)

Add `mcpConnectors` to the input and the run exports records through the Model Context Protocol to supported destinations (Notion and others). See the input schema for the connector shape; `notionParentPageUrl` sets the Notion parent and `maxNotifyListings` caps notification-style exports.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | select | search | Search mode (sport/league) or URL mode (paste links). |
| `sportSlugs` | array | basketball | Sport page slugs (basketball, football, baseball, hockey, soccer, golf, mma). Resolved live from the catalog. |
| `leagues` | array | (empty) | Optional league slugs to narrow the run (e.g. `nba`, `basketball/nba`). |
| `marketGroups` | multi-select | game-lines | Board sections to read: game-lines, team-totals, player-props, futures, game-props. |
| `includeDfs` | boolean | false | Also collect the DFS surface: contest lobby and player salary lists. |
| `dfsSport` | select | (same as sports) | Override the DFS surface's sport. Set on its own (with `includeDfs` off), it collects the contest list only, without player lists. |
| `urls` | array | four sample links | URL mode: sport pages, league pages, game pages, and NBA, NFL, MLB or NHL player-props and futures pages (the default carries one link of each main shape). |
| `fetchDetails` | boolean | false | Read each game's detail page and merge media, parlay content cards and Pick6 multipliers. Bills one detail-enrichment unit per served record. |
| `includeResults` | boolean | false | Also return the final score, winner and venue of every finished game in the selected leagues over the last `resultsDaysBack` days (search mode, or league and sport links in URL mode). One dataset item per finished game. |
| `resultsDaysBack` | integer | 2 | Days back for final scores (1 to 14). |
| `maxItems` | integer | 20 | Maximum records per run. 0 = unlimited. The only cap that stops a run early. |
| `maxPages` | integer | (empty) | Not used: every board read is a single data call, so there are no pages to walk. |
| `state` | select | auto | Book state token for the regional view (auto, AZ, CA, ...). |
| `proxy` | proxy | residential US | Residential US proxies are strongly recommended; the data pages refuse most datacenter exits. |
| `resumeFromRunId` | string | (empty) | Skip record ids already pushed by a previous run (a run id, or `dataset:<id>`). Mutually exclusive with incremental mode. |
| `incrementalMode` | boolean | false | Classify NEW / UPDATED / UNCHANGED / REAPPEARED / EXPIRED between runs; every odds value participates in the fingerprint. |
| `emitUnchanged` | boolean | false | Also push UNCHANGED records in incremental mode. |
| `stateKey` | string | (empty) | Named key for the incremental baseline (default: a hash of the run scope). |
| `ignoreFieldsForChanges` | array | (empty) | Extra fields excluded from the change fingerprint. |
| `mcpConnectors` | array | (empty) | MCP connector definitions for the export side channel. |
| `notionParentPageUrl` | string | (empty) | Notion parent page for the connector export. |
| `maxNotifyListings` | integer | 0 | Cap for notification-style connector exports (0 = the first 50 records). |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

**One board row per game, with the nested market odds:**

```json
{
    "kind": "event",
    "recordId": "event:00000000",
    "eventId": "00000000",
    "name": "Home Team @ Away Team",
    "sportName": "Basketball",
    "leagueName": "League One",
    "startTime": "2027-01-01T00:00:00Z",
    "status": "NOT_STARTED",
    "homeTeam": "Home Team",
    "homeTeamAbbr": "HT",
    "awayTeam": "Away Team",
    "awayTeamAbbr": "AT",
    "homeMoneylineAmerican": "-110",
    "awayMoneylineAmerican": "-110",
    "spreadLine": 2.5,
    "spreadHomeAmerican": "-108",
    "spreadAwayAmerican": "-112",
    "totalLine": 210.5,
    "overAmerican": "-108",
    "underAmerican": "-112",
    "marketGroupLabel": "Game lines (moneyline, spread, total)",
    "subcategoryLabel": "Game Lines",
    "markets": [
        {
            "marketId": "1_00000000",
            "name": "Moneyline",
            "marketTypeName": "Moneyline",
            "subcategoryLabel": "Game Lines",
            "isPrimaryMarket": true,
            "selections": [
                {
                    "selectionId": "0ML00000000_1",
                    "label": "Home Team",
                    "points": null,
                    "outcomeType": "Home",
                    "oddsAmerican": "-110",
                    "oddsDecimal": "1.91",
                    "oddsFractional": "100/110",
                    "impliedProbability": "52%",
                    "trueOdds": 1.91,
                    "participantNames": ["Home Team"]
                }
            ]
        }
    ],
    "url": "https://sportsbook.draftkings.com/event/sample-game/00000000",
    "capturedAt": "2027-01-01T00:00:00Z"
}
```

**One result row per finished game (Final scores of past games on):**

| Field | Example |
| --- | --- |
| kind | result |
| recordId | result:sd:0000000 |
| eventId | 00000000 |
| matchKey | league-one|2027-01-01|away-team@home-team |
| source | stats |
| name | Away Team @ Home Team |
| sportName | Hockey |
| leagueName | League One |
| startTime | 2027-01-01T00:00:00Z |
| status | Final |
| statusDetail | Final/OT |
| homeTeam | Home Team |
| awayTeam | Away Team |
| homeTeamAbbr | HT |
| awayTeamAbbr | AT |
| homeScore | 2 |
| awayScore | 3 |
| winner | away |
| winnerTeam | Away Team |
| venue | Sample Arena, Sample City |
| threeStars | Player One, Player Two, Player Three |
| capturedAt | 2027-01-01T06:00:00Z |

### Plan Requirement

This actor collects the book's publicly served odds board, DFS lobby and player lists, and requires a residential US connection (set by default). No account, sign-in or subscription of any kind is used: every record comes from the same pages and data responses the site serves to its own visitors.

### FAQ

#### How much does it cost? Each run bills the Actor start once (one start unit per GB of memory, one at the default 512 MB), then one dataset-item unit per pushed record (board row, final-score result row, DFS contest or DFS player, plus UNCHANGED rows when `emitUnchanged` is on and EXPIRED rows in incremental mode; suppressed UNCHANGED rows are never pushed or billed), plus one detail-enrichment unit per board record whose detail read succeeded when Detail enrichment is on. At the published prices, a 20-game board run with detail enrichment on costs a fraction of a cent per record; see the Pricing tab for the live per-event rates.

#### Is it legal to scrape DraftKings? The actor reads the same publicly served odds board, contest lobby and player lists the site shows its own visitors, without any account or sign-in, and only at the rate of a single reader. Scraping publicly available data is a common practice; always review the site's terms and your own jurisdiction before commercial use.

#### Can I schedule it to watch line moves? Yes. Turn on incremental mode and schedule the run; UNCHANGED rows are suppressed by default, UPDATED rows carry `changedFields` naming exactly which odds moved, and records that vanish from a complete scan are reported EXPIRED (fantasy contests and players are a bounded sample and are never reported EXPIRED). Final-score result rows are delivered once per game and never reported EXPIRED; a later score correction arrives as one UPDATED row.

#### Why did a run return fewer records than expected? Max items (default 20) is the only cap that stops a run early; raise it for whole-board runs. With several leagues it is split evenly across them, and with final scores on, up to half of it is kept for new or changed result rows (none kept when there are no such rows). The board also thins out overnight in the US off-season hours: fewer games are posted between windows, and futures sections carry one event per award.

#### Why did my run fail with an upgrade note? The book's data pages refuse most datacenter connections, so the actor defaults to residential US proxies, which paid plans include. Free plans have no residential access: the run logs a boxed note saying so, then continues on a backup connection when one is available to the run (some pages may still be unavailable). The run fails with the upgrade note only when every connection was refused, so no page could be read; it never ends as an empty success.

#### Can I use it with AI agents or MCP? Yes. The dataset is plain JSON records, the Output tabs expose per-kind views, and `mcpConnectors` exports records to supported MCP destinations after the run.

### 🔗 Want more sports data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>⚽ <a href="https://apify.com/abotapi/fanduel-odds-scraper"><b>FanDuel Odds Scraper</b></a><br>Scrape FanDuel sportsbook odds, including moneylines, spreads, totals, player props and...</td><td>⚽ <a href="https://apify.com/abotapi/sportsbook-odds-scraper"><b>Sportsbook Odds Scraper (1xBet, Melbet, Linebet, Paripulse)</b></a><br>Collect live and prematch betting odds from 1xBet, Melbet, Linebet and Paripulse. Give it...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/bet365-odds-scraper"><b>bet365 Odds Scraper</b></a><br>Scrape bet365 live in-play and pre-match odds across 20+ sports. Extract fixture...</td><td>⚽ <a href="https://apify.com/abotapi/fotmob-scraper"><b>FotMob Scraper ⚽ Match Details, Stats, Lineups &amp; Players</b></a><br>Pull structured football data from FotMob: match details with scores, team stats, events...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/sofascore-scraper"><b>SofaScore Scraper ⚽ Live Scores, Stats, Players &amp; Odds</b></a><br>Pull structured sports data from SofaScore across football, basketball, tennis, and 20+...</td><td>⚽ <a href="https://apify.com/abotapi/sportsbet-au-scraper"><b>Sportsbet AU Scraper 🏅 Sports Odds &amp; Racing Prices</b></a><br>Scrape sportsbet.com.au odds: events, markets, selections and prices for AFL, NRL...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/draftkings-sportsbook-odds-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

Search mode walks the selected sports and leagues. URL mode scrapes exactly the pasted sportsbook links (league, event, player-props or futures pages); filter fields are ignored.

## `sportSlugs` (type: `array`):

Sport page slugs, e.g. basketball, football, baseball, hockey, soccer, golf, mma. The full catalog is resolved live from the site's own league list.

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

Optional league slugs to narrow the run, e.g. 'nba' or 'basketball/nba'. Leave empty for every league under the selected sports.

## `marketGroups` (type: `array`):

Which board sections to read. Each adds one data read per league. Game lines carry the flagship moneyline/spread/total board.

## `includeDfs` (type: `boolean`):

Also collect the daily-fantasy surface for the selected sport: contest list (fees, prize pools, entries) and player lists with salaries, positions and stats.

## `dfsSport` (type: `string`):

Override the DFS surface's sport. Defaults to the first selected search sport.

## `state` (type: `string`):

The book serves its national board by default; pick a state token to read that state's region view.

## `urls` (type: `array`):

League pages, game pages, player-props pages and futures pages are all supported; the default carries one live link of every supported shape. Multi-URL runs walk each link once; market-group filters do not apply.

## `fetchDetails` (type: `boolean`):

Read each game's detail page and merge event media, parlay content cards and Pick6 multipliers onto its row. Adds one detail-enrichment charge per served record.

## `includeResults` (type: `boolean`):

Also return the result of every finished game in the selected leagues (search mode, or league and sport links in URL mode): home and away team, final score, winner, venue and the odds event id where it can be linked. One row per finished game; games not yet over are never returned. Covered: NFL, NBA, MLB, NHL, college football and basketball, and the major soccer leagues and cups. Each result row is one dataset item.

## `resultsDaysBack` (type: `integer`):

How many days back to collect final scores (1 to 14). Only used when Final scores of past games is on.

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

Maximum records per run. 0 means unlimited. This is the only cap that stops a run early.

## `maxPages` (type: `integer`):

Not used by this actor: every board read is a single data call, so there are no pages to walk. Leave empty; Max items is the only cap.

## `proxy` (type: `object`):

Residential US proxies are strongly recommended: the data pages refuse most datacenter exits. Free plans have no residential access, so those runs fall back or fail with an upgrade note.

## `resumeFromRunId` (type: `string`):

Run id of a previous run of this Actor: already-pushed record ids are skipped. Mutually exclusive with incremental mode.

## `incrementalMode` (type: `boolean`):

Track records between runs and classify NEW / UPDATED / UNCHANGED / EXPIRED. The fingerprint covers every odds value (a line move classifies UPDATED); run bookkeeping, detail-merge fields (media, parlay cards, Pick6 multipliers) and capturedAt are excluded. Records absent from a complete scan are tombstoned EXPIRED.

## `emitUnchanged` (type: `boolean`):

In incremental mode, also push UNCHANGED records (default: suppressed).

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

Named key for the incremental baseline. Default: a hash of the run's scope (sports, leagues, market groups, links, toggles).

## `ignoreFieldsForChanges` (type: `array`):

Extra record fields (top-level names or dotted paths) excluded from the change fingerprint.

## `mcpConnectors` (type: `array`):

Connector definitions for the MCP export side channel.

## `notionParentPageUrl` (type: `string`):

Optional Notion parent page for the Notion connector export.

## `maxNotifyListings` (type: `integer`):

Cap for notification-style connector exports. 0 means the first 50 records.

## Actor input object example

```json
{
  "mode": "search",
  "sportSlugs": [
    "basketball"
  ],
  "marketGroups": [
    "game-lines"
  ],
  "includeDfs": false,
  "state": "auto",
  "urls": [
    {
      "url": "https://sportsbook.draftkings.com/leagues/basketball/nba"
    },
    {
      "url": "https://sportsbook.draftkings.com/event/mil-bucks-%40-ny-knicks/34983855"
    },
    {
      "url": "https://sportsbook.draftkings.com/page/nba-player-props"
    },
    {
      "url": "https://sportsbook.draftkings.com/page/nba-futures"
    }
  ],
  "fetchDetails": false,
  "includeResults": false,
  "resultsDaysBack": 2,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "incrementalMode": false,
  "emitUnchanged": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `events` (type: `string`):

No description

## `markets` (type: `string`):

No description

## `dfs` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `gameResults` (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 = {
    "mode": "search",
    "sportSlugs": [
        "basketball"
    ],
    "marketGroups": [
        "game-lines"
    ],
    "state": "auto",
    "urls": [
        {
            "url": "https://sportsbook.draftkings.com/leagues/basketball/nba"
        },
        {
            "url": "https://sportsbook.draftkings.com/event/mil-bucks-%40-ny-knicks/34983855"
        },
        {
            "url": "https://sportsbook.draftkings.com/page/nba-player-props"
        },
        {
            "url": "https://sportsbook.draftkings.com/page/nba-futures"
        }
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/draftkings-sportsbook-odds-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "sportSlugs": ["basketball"],
    "marketGroups": ["game-lines"],
    "state": "auto",
    "urls": [
        { "url": "https://sportsbook.draftkings.com/leagues/basketball/nba" },
        { "url": "https://sportsbook.draftkings.com/event/mil-bucks-%40-ny-knicks/34983855" },
        { "url": "https://sportsbook.draftkings.com/page/nba-player-props" },
        { "url": "https://sportsbook.draftkings.com/page/nba-futures" },
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/draftkings-sportsbook-odds-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "sportSlugs": [
    "basketball"
  ],
  "marketGroups": [
    "game-lines"
  ],
  "state": "auto",
  "urls": [
    {
      "url": "https://sportsbook.draftkings.com/leagues/basketball/nba"
    },
    {
      "url": "https://sportsbook.draftkings.com/event/mil-bucks-%40-ny-knicks/34983855"
    },
    {
      "url": "https://sportsbook.draftkings.com/page/nba-player-props"
    },
    {
      "url": "https://sportsbook.draftkings.com/page/nba-futures"
    }
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call abotapi/draftkings-sportsbook-odds-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/draftkings-sportsbook-odds-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/PMbr3K19sfGDNssSG/builds/WbHnkcRfy6wbyuszk/openapi.json