# DraftKings Odds + Player Props API (`khadinakbar/scrape-draftkings-odds-player-props`) Actor

Fetch DraftKings sportsbook odds and player props by event group. Returns moneyline, spread, totals, and player over/unders as normalized dataset rows. MCP-ready.

- **URL**: https://apify.com/khadinakbar/scrape-draftkings-odds-player-props.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Developer tools, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 odds rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## DraftKings Odds + Player Props API

**Fetch live DraftKings sportsbook odds and player props in seconds — no login, no browser, pure JSON API.**

This Actor hits DraftKings' public sportsbook JSON endpoints and returns every market row (moneyline, spread, totals, and player props) in a clean normalized schema ready for betting algorithms, arbitrage detection, and sports analytics pipelines. Try it for free on [Apify](https://apify.com/khadinakbar/scrape-draftkings-odds-player-props).

### What does DraftKings Odds + Player Props API do?

- Fetches the DraftKings public sportsbook event-group endpoint and player props category endpoint over plain HTTPS (no session, no login).
- Normalizes raw JSON into flat, stable rows: `rowType`, `eventName`, `marketName`, `participant`, `label`, `line`, `oddsAmerican`, `oddsDecimal`, `selectionId`, `marketId`.
- Separates standard odds markets from player prop markets by row type (`odds` vs `player-prop`) in the same dataset.
- Returns an `OUTPUT` / `RUN_SUMMARY` record with `outcome`, row counts, and billing evidence on every terminal path.

### Why use DraftKings Odds + Player Props API?

- **Sports betting research** — pull real-time moneylines, spreads, and totals for any sport.
- **Player props arbitrage** — compare over/under lines across multiple players in a single dataset.
- **ML pipelines** — structured rows drop cleanly into pandas, BigQuery, or any columnar store.
- **No browser overhead** — HTTP-only means fast, cheap, and reliable runs without Playwright.

### How to use

1. Open the Actor on Apify and click **Try for free**.
2. Enter the **Event Group ID** for the sport/event you want (default: `88808` NFL; `88809` NBA is another common one).
3. Toggle **Fetch Odds Markets** and/or **Fetch Player Props** on/off.
4. Set **Max Output Rows** (default 500; max 5000).
5. Click **Start** — runs complete in seconds.
6. Download the dataset as JSON, CSV, or Excel from the Output tab.

You can also supply custom endpoint URLs via `oddsApiUrl` / `propsApiUrl` to target any DraftKings state endpoint directly.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `eventGroupId` | string | `88808` | DraftKings event group ID (sport/league) |
| `includeOdds` | boolean | `true` | Fetch standard odds markets |
| `includePlayerProps` | boolean | `true` | Fetch player prop markets |
| `oddsApiUrl` | string | auto | Override the odds endpoint URL |
| `propsApiUrl` | string | auto | Override the props endpoint URL |
| `maxRows` | integer | `500` | Max rows to output (1–5000) |
| `timeoutSecs` | integer | `25` | Per-request timeout in seconds (5–120) |

Example JSON input:

```json
{
  "eventGroupId": "88808",
  "includeOdds": true,
  "includePlayerProps": true,
  "maxRows": 200
}
```

### Output

Each dataset row is a normalized market selection:

```json
{
  "rowType": "player-prop",
  "sourceType": "props",
  "eventId": "28345678",
  "eventName": "Team A vs Team B",
  "marketId": "12345",
  "marketName": "Player Receiving Yards",
  "selectionId": "67890",
  "participant": "John Smith",
  "label": "Over 72.5",
  "line": 72.5,
  "oddsAmerican": "-115",
  "oddsDecimal": 1.87,
  "categoryPath": "eventGroupsResp > eventGroup > offerCategories > offerDisplayGroups"
}
```

| Field | Description |
|---|---|
| `rowType` | `odds` or `player-prop` |
| `sourceType` | `odds` (event-group API) or `props` (category API) |
| `eventId` | DraftKings event identifier |
| `eventName` | Human-readable game/match name |
| `marketId` | Market identifier |
| `marketName` | Market label (e.g. "Spread", "Player Points") |
| `selectionId` | Individual selection identifier |
| `participant` | Player name (player props only) |
| `label` | Selection label (e.g. "Over 22.5", "Team A -3") |
| `line` | Numeric spread/total line (when available) |
| `oddsAmerican` | American odds string (e.g. "-110") |
| `oddsDecimal` | Decimal odds number (e.g. 1.91) |
| `categoryPath` | Nested JSON path for debugging |

You can download the dataset in JSON, HTML, CSV, or Excel via the Apify UI or API.

### Pricing / Cost estimation

Billing is **pay-per-event**:

- `odds-row-scraped` — **$0.002/row** for standard market selections
- `prop-row-scraped` — **$0.003/row** for player prop selections
- `apify-actor-start` — $0.00005 per run start

A typical NFL week with 200 odds rows + 150 player prop rows costs about **$0.85**. All start costs are under $0.001.

### Tips

- Use a specific state endpoint URL in `oddsApiUrl` (e.g. US-CO-SB or US-NJ-SB) for state-specific lines.
- Set `maxRows` low during testing, then raise it for production.
- DraftKings endpoints are geo-gated — runs execute from Apify's US servers which are within the supported regions.
- The default player props category is `1215` (DFS-style props); override `propsApiUrl` to target a different category.

### FAQ & Disclaimer

**Is this legal?** This Actor fetches publicly accessible JSON endpoints that any browser tab requests when visiting the DraftKings website. It does not bypass any authentication, access restricted accounts, or violate any technical protection measures. The data is read-only and public. Always review DraftKings' Terms of Service before commercial use.

**What if rows are empty?** DraftKings endpoints can return no active markets outside of game windows or for events with no betting action. The Actor will return a `VALID_EMPTY` outcome in that case.

**The odds look stale.** DraftKings returns cached JSON; re-run the Actor for fresh data. For real-time polling, use an [Apify Schedule](https://docs.apify.com/platform/schedules).

**Can I get multiple sports in one run?** Not in a single run — one `eventGroupId` per run. Chain runs using Apify Workflows or call the Actor via API with different IDs.

Found a bug? Open an issue on the [Issues tab](https://console.apify.com/actors/khadinakbar/scrape-draftkings-odds-player-props/issues) or contact us for a custom solution.

*This Actor is not affiliated with or endorsed by DraftKings Inc. All sports data remains the property of DraftKings Inc.*

# Actor input Schema

## `eventGroupId` (type: `string`):

DraftKings event group identifier (for example: 88808 NFL, 88809 NBA).

## `includeOdds` (type: `boolean`):

If true, fetches standard odds markets for the event group.

## `includePlayerProps` (type: `boolean`):

If true, fetches DraftKings player props markets.

## `oddsApiUrl` (type: `string`):

Override URL for odds endpoint. Leave empty to use the default DraftKings event-group endpoint.

## `propsApiUrl` (type: `string`):

Override URL for player props endpoint. Leave empty to use default category endpoint.

## `maxRows` (type: `integer`):

Maximum number of normalized dataset rows to output.

## `timeoutSecs` (type: `integer`):

Per-request timeout in seconds for DraftKings endpoint fetches.

## Actor input object example

```json
{
  "eventGroupId": "88808",
  "includeOdds": true,
  "includePlayerProps": true,
  "maxRows": 500,
  "timeoutSecs": 25
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

No description

## `runOutput` (type: `string`):

No description

## `runSummary` (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 = {
    "eventGroupId": "88808"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/scrape-draftkings-odds-player-props").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "eventGroupId": "88808" }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/scrape-draftkings-odds-player-props").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "eventGroupId": "88808"
}' |
apify call khadinakbar/scrape-draftkings-odds-player-props --silent --output-dataset

```

## MCP server setup

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

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DIZaQAlgORnWcKg4k/builds/zpVDaxB3XiACLUHmc/openapi.json