# FanDuel Sportsbook Odds Scraper (`parseforge/fanduel-scraper`) Actor

Scrape live FanDuel Sportsbook odds in real time: moneylines, spreads, totals, futures, and runners across NFL, NBA, MLB, NHL, MMA, soccer, and tennis.

- **URL**: https://apify.com/parseforge/fanduel-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, Lead generation
- **Stats:** 10 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/.github/main/banner.png)

## 🎰 FanDuel Scraper

> 🚀 **Pull live FanDuel Sportsbook odds in seconds.** Filter by league, scrape moneyline, spread, total, and futures markets. No API key, no registration, no manual line-watching.

> 🕒 **Last updated:** 2026-05-05 · **📊 28 fields** per record · **7 leagues covered** · **moneyline + spread + total + futures** · **American & decimal odds**

FanDuel runs the largest sportsbook in the United States and posts a constantly shifting board of game lines, prop markets, and futures across **NFL, NBA, MLB, NHL, MMA, soccer, and tennis**. The public web app reads from a JSON feed that we tap directly, which means every record arrives fully structured: home and away teams, American odds, decimal odds, point spreads, totals, and the underlying market identifiers FanDuel uses to keep the board in sync. There is no captcha pass, no headless browser, and no waiting for a page to render.

This Actor was built for line shoppers, arbitrage hunters, model builders, and anyone tracking how FanDuel prices the market against the rest of the industry. You pick a sport, set a cap, and get back a flat dataset that drops straight into Excel, Sheets, BigQuery, or your favorite betting model. Logos, league names, and event start times come pre-formatted, and the same record shape works for game-line markets and league futures, so a single pipeline handles both. Free runs are capped at 10 records so you can preview the schema before committing.

| 🎯 Target Audience | 💡 Primary Use Cases |
|--------------------|----------------------|
| Sports bettors and sharps | Line shopping across sportsbooks |
| Odds comparison and aggregator services | Building real-time best-price feeds |
| Sports analytics and model-building teams | Closing-line value tracking and EV models |
| Betting pool operators and pick'em apps | Auto-updating spreads, totals, and props for members |

---

### 📋 What the FanDuel Scraper does

- 🏈 **Filter by league.** Pick NFL, NBA, MLB, NHL, MMA, soccer, tennis, or scrape every supported league at once.
- 💰 **Capture the big three.** Every game-line record contains moneyline, spread, and total in one row.
- 🎯 **Optional futures.** Toggle a flag and pull division winners, championship outright odds, and award markets next to the game lines.
- 🔢 **Bound the run.** Use `maxItems` to keep test runs cheap and full pulls predictable.
- 🌎 **Multi-state failover.** The scraper rotates through FanDuel state hosts automatically so a single regional outage will not break your pipeline.

Each record carries event identifiers, team names and abbreviations, official team logos, ISO and human-friendly start times, in-play status, and both American and decimal odds for every line. Futures records add a `runners` array with one entry per contender, each with its own American odds, decimal odds, and team logo, so you can rebuild a complete futures board from a single row.

> 💡 **Why it matters:** A single sportsbook never tells you the full price story. Pairing FanDuel with other books exposes the soft sides of the market, the books that move first, and the situations where the public sits on a stale number. This Actor is the FanDuel half of that comparison, structured the same way as our DraftKings Scraper so you can join the two on event names with one query.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough of running the Actor and joining the output to a second sportsbook for line shopping.

---

### ⚙️ Input

<table>
  <thead>
    <tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
  </thead>
  <tbody>
    <tr>
      <td><code>maxItems</code></td>
      <td>integer</td>
      <td>No (prefilled 10)</td>
      <td>Caps the number of records returned. Free plans are limited to 10. Paid plans can request up to 1,000,000.</td>
    </tr>
    <tr>
      <td><code>sport</code></td>
      <td>enum</td>
      <td>Yes</td>
      <td>One of <code>ALL</code>, <code>NFL</code>, <code>NBA</code>, <code>MLB</code>, <code>NHL</code>, <code>MMA</code>, <code>SOC</code>, <code>TEN</code>.</td>
    </tr>
    <tr>
      <td><code>includeFutures</code></td>
      <td>boolean</td>
      <td>No</td>
      <td>When true, the dataset also contains league futures and outright winner markets in addition to game lines.</td>
    </tr>
  </tbody>
</table>

Example: scrape today's MLB game lines.

```json
{
    "sport": "MLB",
    "maxItems": 100,
    "includeFutures": false
}
````

Example: pull every supported league plus championship futures.

```json
{
    "sport": "ALL",
    "maxItems": 5000,
    "includeFutures": true
}
```

> ⚠️ **Good to Know:** Odds move constantly. A line you scrape at 2:00 PM may already be stale by 2:05 PM. For best-price work, run the Actor on a schedule (every 1 to 5 minutes is typical) and key on `eventId` to detect line movement between runs.

***

### 📊 Output

Every run produces a flat JSON dataset. Each row is either a game-line event or, when `includeFutures` is enabled, a league futures market. You can download the results as JSON, CSV, Excel, HTML, or XML.

#### 🧾 Schema

| Field | Type | Example |
|-------|------|---------|
| 🖼️ `imageUrl` | string | `https://assets.sportsbook.fanduel.com/images/team/mlb/miami_marlins.png` |
| 🆔 `eventId` | number | `35570352` |
| 📛 `eventName` | string | `Baltimore Orioles (C Bassitt) @ Miami Marlins (S Alcantara)` |
| 🏷️ `sport` | string | `MLB` |
| 🏟️ `sportName` | string | `Baseball` |
| 🏆 `league` | string | `MLB` |
| 🏠 `homeTeam` | string | `Miami Marlins` |
| ✈️ `awayTeam` | string | `Baltimore Orioles` |
| 🔠 `homeTeamAbbr` | string | `MIA Marlins` |
| 🔠 `awayTeamAbbr` | string | `BAL Orioles` |
| 🖼️ `awayTeamLogo` | string | `https://assets.sportsbook.fanduel.com/images/team/mlb/baltimore_orioles.png` |
| ⏰ `startTime` | string | `May 5, 2026, 6:41 PM` |
| 🟢 `inPlay` | boolean | `true` |
| 💵 `moneylineHome` | number | `132` |
| 💵 `moneylineAway` | number | `-170` |
| 🔢 `moneylineHomeDecimal` | number | `2.32` |
| 🔢 `moneylineAwayDecimal` | number | `1.59` |
| 📐 `spreadHome` | number | `1.5` |
| 📐 `spreadHomeOdds` | number | `-158` |
| 📐 `spreadAway` | number | `-1.5` |
| 📐 `spreadAwayOdds` | number | `118` |
| 📊 `totalLine` | number | `14.5` |
| 📊 `totalOverOdds` | number | `-120` |
| 📊 `totalUnderOdds` | number | `-110` |
| 🪪 `primaryMarketId` | string | `734.167451276` |
| 🪪 `competitionId` | number | `11196870` |
| 🔗 `url` | string | `https://sportsbook.fanduel.com/mlb/35570352` |
| 🕒 `scrapedAt` | string (ISO 8601) | `2026-05-05T23:53:57.308Z` |

Futures records share the same record shape but add `marketId`, `marketName`, `marketType`, `numberOfRunners`, `marketTime`, and a `runners` array with one entry per contender.

#### 📦 Sample records

<details>
<summary><strong>Typical: MLB regular-season game line</strong></summary>

```json
{
    "imageUrl": "https://assets.sportsbook.fanduel.com/images/team/mlb/miami_marlins.png",
    "eventId": 35570352,
    "eventName": "Baltimore Orioles (C Bassitt) @ Miami Marlins (S Alcantara)",
    "sport": "MLB",
    "sportName": "Baseball",
    "league": "MLB",
    "homeTeam": "Miami Marlins",
    "awayTeam": "Baltimore Orioles",
    "homeTeamAbbr": "MIA Marlins",
    "awayTeamAbbr": "BAL Orioles",
    "awayTeamLogo": "https://assets.sportsbook.fanduel.com/images/team/mlb/baltimore_orioles.png",
    "startTime": "May 5, 2026, 6:41 PM",
    "inPlay": true,
    "moneylineHome": 132,
    "moneylineAway": -170,
    "moneylineHomeDecimal": 2.32,
    "moneylineAwayDecimal": 1.59,
    "spreadHome": 1.5,
    "spreadHomeOdds": -158,
    "spreadAway": -1.5,
    "spreadAwayOdds": 118,
    "totalLine": 14.5,
    "totalOverOdds": -120,
    "totalUnderOdds": -110,
    "primaryMarketId": "734.167451276",
    "competitionId": 11196870,
    "url": "https://sportsbook.fanduel.com/mlb/35570352",
    "scrapedAt": "2026-05-05T23:53:57.308Z"
}
```

</details>

<details>
<summary><strong>Edge case: WNBA Championship futures market</strong></summary>

```json
{
    "imageUrl": "https://assets.sportsbook.fanduel.com/images/team/wnba/new_york_liberty.png",
    "marketId": "734.161494168",
    "marketName": "WNBA Championship Winner 2026",
    "marketType": "WNBA_CHAMPIONSHIP",
    "sport": "NBA",
    "sportName": "Basketball",
    "league": "WNBA Futures",
    "eventId": 34269332,
    "competitionId": 12731476,
    "marketTime": "Oct 20, 2026, 7:00 AM",
    "inPlay": false,
    "numberOfRunners": 15,
    "runners": [
        { "name": "New York Liberty", "nameAbbr": "NY Liberty", "americanOdds": 230, "decimalOdds": 3.3, "logo": "https://assets.sportsbook.fanduel.com/images/team/wnba/new_york_liberty.png", "status": "ACTIVE" },
        { "name": "Las Vegas Aces", "nameAbbr": "LV Aces", "americanOdds": 440, "decimalOdds": 5.4, "logo": "https://assets.sportsbook.fanduel.com/images/team/wnba/las_vegas_aces.png", "status": "ACTIVE" },
        { "name": "Indiana Fever", "nameAbbr": "IND Fever", "americanOdds": 500, "decimalOdds": 6, "logo": "https://assets.sportsbook.fanduel.com/images/team/wnba/indiana_fever.png", "status": "ACTIVE" }
    ],
    "url": "https://sportsbook.fanduel.com/navigation/nba",
    "scrapedAt": "2026-05-05T23:52:29.302Z"
}
```

</details>

<details>
<summary><strong>Sparse: NCAA baseball game with no team logos available upstream</strong></summary>

```json
{
    "imageUrl": "",
    "eventId": 35572216,
    "eventName": "Clemson Tigers @ Coastal Carolina Chanticleers",
    "sport": "MLB",
    "sportName": "Baseball",
    "league": "NCAA - Baseball",
    "homeTeam": "Coastal Carolina Chanticleers",
    "awayTeam": "Clemson Tigers",
    "homeTeamAbbr": "",
    "awayTeamAbbr": "",
    "awayTeamLogo": "",
    "startTime": "May 5, 2026, 6:00 PM",
    "inPlay": true,
    "moneylineHome": 188,
    "moneylineAway": -255,
    "moneylineHomeDecimal": 2.88,
    "moneylineAwayDecimal": 1.39,
    "spreadHome": -1.5,
    "spreadHomeOdds": 100,
    "spreadAway": 1.5,
    "spreadAwayOdds": -130,
    "totalLine": 13.5,
    "totalOverOdds": -125,
    "totalUnderOdds": -104,
    "primaryMarketId": "734.167583616",
    "competitionId": 11363642,
    "url": "https://sportsbook.fanduel.com/ncaa---baseball/35572216",
    "scrapedAt": "2026-05-05T23:53:57.310Z"
}
```

</details>

***

### ✨ Why choose this Actor

| 🔍 | Capability |
|----|------------|
| 💸 | **Both odds formats.** Every moneyline ships with American and decimal odds, so European and US workflows both work without extra math. |
| 🛰️ | **State-host failover.** The scraper rotates through 18 FanDuel state hosts on every retry, smoothing over single-region outages. |
| 🧱 | **Flat schema.** Game lines arrive as one row per event with the big three (moneyline, spread, total) in the same record. No follow-up calls. |
| 🎯 | **Optional futures.** Flip one boolean and the same dataset adds league futures with full runner-level breakdowns. |
| ⚡ | **API-first.** No headless browser, no captcha pass. Runs cost cents, even at scale. |
| 🤝 | **Pairs with DraftKings Scraper.** Identical event identifiers shape, identical record format, ready for line-shopping joins. |
| 🧾 | **Predictable cost.** `maxItems` is honored exactly, so test runs stay cheap and production runs are easy to budget. |

> 📊 A typical NFL Sunday returns 14 game lines and 6 to 12 futures markets in under 3 seconds.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|----------|------|----------|---------|---------|-------|
| ⭐ **FanDuel Scraper** *(this Actor)* | Pay per run | All 7 supported leagues | Real-time on demand | Sport, futures toggle, maxItems | None, ready to run |
| Paid live odds APIs | Subscription, often $500+/mo | Multi-book | Streaming | Vendor-defined | Account, billing, key rotation |
| Manual screenshots | Free, time-expensive | Whatever you watch | Whenever you remember | None | Browser only |
| Generic web scrapers | Pay per run | Variable | Real-time | DIY selectors | Custom scripts and maintenance |
| Internal feed integrations | Negotiated | Single book | Streaming | Vendor-defined | Months of contracts |

For most line-shopping and modeling work, a scheduled run of this Actor delivers the same data as a paid feed at a fraction of the cost.

***

### 🚀 How to use

1. 🔑 **Sign up.** Create a free Apify account at [console.apify.com/sign-up?fpr=vmoqkp](https://console.apify.com/sign-up?fpr=vmoqkp).
2. 🎯 **Open the Actor.** Find the FanDuel Scraper in your console and click **Try for free**.
3. ⚙️ **Pick your sport and cap.** Set `sport` (or leave it on `ALL`) and a sensible `maxItems` for your test.
4. ▶️ **Run it.** Click **Start**. The first records appear within a couple of seconds.
5. 📥 **Export.** Download the dataset as JSON, CSV, or Excel, or pipe it into your warehouse via the Apify API.

> ⏱️ Total time: under 3 minutes from sign-up to first dataset.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 📈 Odds aggregators and best-price feeds

- Power "best line" widgets across multiple sportsbooks
- Ship affiliate-driven price comparison pages
- Detect arbitrage windows in real time
- Backstop a primary feed during vendor outages

</td>
<td width="50%">

#### 🧠 Quant and modeling teams

- Track closing line value (CLV) across a full season
- Validate model edges against live FanDuel pricing
- Build training datasets of opening, intraday, and closing lines
- Compare implied probabilities versus model probabilities

</td>
</tr>
<tr>
<td width="50%">

#### 📺 Media and content

- Pre-game articles with up-to-the-minute odds tables
- Automated social posts when lines cross key thresholds
- Newsletters that quote real numbers, not stale snapshots
- Podcast and stream lower-third graphics

</td>
<td width="50%">

#### 🎲 Pool and pick'em operators

- Auto-update weekly spreads and totals for members
- Generate confidence-pool point values from market odds
- Sync survivor-pool win probabilities with live moneylines
- Settle props from a known-source feed

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating FanDuel Scraper

Plug the Actor into anything that can call an HTTP endpoint. Apify ships first-class clients in every popular language and a built-in scheduler.

- 🟦 **Node.js / TypeScript:** use [`apify-client`](https://docs.apify.com/api/client/js/) to fire runs and pull dataset items in a few lines.
- 🐍 **Python:** the [Apify Python client](https://docs.apify.com/api/client/python/) wraps the same API for data science notebooks and Airflow DAGs.
- 📚 **Reference docs:** the full [Apify API](https://docs.apify.com/api/v2) gives you raw HTTP control for any other stack.

For continuous odds tracking, attach the Actor to an [Apify Schedule](https://docs.apify.com/platform/schedules) and have it run every 1, 5, or 15 minutes. Output goes to a versioned dataset you can stream into BigQuery, Snowflake, or your own database.

***

### ❓ Frequently Asked Questions

<details>
<summary>🌎 <strong>Is the data live?</strong></summary>

Yes. Every run pulls the FanDuel feed at the moment the run starts. There is no caching layer between you and FanDuel.

</details>

<details>
<summary>🏈 <strong>Which sports are supported?</strong></summary>

NFL (American football, including major college games), NBA (basketball, including WNBA futures), MLB (baseball, including NCAA), NHL (ice hockey), MMA, soccer (every league FanDuel posts), and tennis. Pick `ALL` to scrape every supported league in one run.

</details>

<details>
<summary>🧮 <strong>What odds formats do you return?</strong></summary>

American (moneyline) and decimal odds for every line. The mapping is exact, so you do not have to convert.

</details>

<details>
<summary>🎯 <strong>Can I get player props?</strong></summary>

The current build returns the big three game lines (moneyline, spread, total) plus league futures. Player props live behind a separate per-event endpoint and are on the roadmap.

</details>

<details>
<summary>⏱️ <strong>How fresh is each row?</strong></summary>

Every record carries a `scrapedAt` ISO timestamp marking the exact second it was pulled. Pair it with `eventId` to track movement run over run.

</details>

<details>
<summary>🔑 <strong>Do I need a FanDuel account or API key?</strong></summary>

No. The Actor uses the same public JSON feed the FanDuel web app reads. No authentication, no key, no geographic gating on your end.

</details>

<details>
<summary>💼 <strong>Can I use this for commercial projects?</strong></summary>

Yes. The dataset is yours to use in commercial products, internal tools, paid newsletters, or client work, subject to Apify's terms and any third-party rights in the underlying data. You are responsible for complying with local gambling and advertising regulations.

</details>

<details>
<summary>💳 <strong>Do I need a paid Apify plan?</strong></summary>

No. You can run the Actor on the free tier. Free runs are limited to 10 records per run so you can preview the schema. Paid plans lift the cap to 1,000,000 records.

</details>

<details>
<summary>🛑 <strong>What happens if a run fails?</strong></summary>

The Actor retries each request across multiple FanDuel state hosts before giving up, so transient failures recover automatically. If a run still fails, the dataset will contain a single row with an `error` field describing the cause, and Apify will not bill the run.

</details>

<details>
<summary>⚖️ <strong>Is scraping FanDuel legal?</strong></summary>

The Actor only reads the same public JSON feed your browser fetches when you visit the FanDuel website, and the data itself (odds and team names) is public. As with any scraper, you are responsible for using the data in compliance with applicable laws and the source site's terms of service in your jurisdiction.

</details>

<details>
<summary>📦 <strong>What output formats can I export?</strong></summary>

JSON, CSV, Excel, HTML, and XML. You can also stream the dataset directly via the Apify API into your warehouse.

</details>

<details>
<summary>🔁 <strong>Can I run it on a schedule?</strong></summary>

Yes. Use Apify Schedules to run the Actor every minute, every 5 minutes, or whatever cadence your workflow needs. Each run produces a fresh, timestamped dataset.

</details>

***

### 🔌 Integrate with any app

- [**Google Sheets**](https://apify.com/apify/google-sheets) - pipe odds straight into a live spreadsheet for quick analysis.
- [**Airtable**](https://apify.com/lukaskrivka/airtable-import) - sync each run into a structured Airtable base.
- [**Slack**](https://apify.com/apify/slack-integration) - get pings when key lines cross thresholds.
- [**Zapier**](https://zapier.com/apps/apify) - trigger thousands of downstream actions from any FanDuel run.
- [**Make**](https://www.make.com/en/integrations/apify) - drop the Actor into multi-step workflows visually.
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) - POST results to your own endpoints in real time.

***

### 🔗 Recommended Actors

- [**🏈 DraftKings Scraper**](https://apify.com/parseforge/draftkings-scraper) - the natural pair for line shopping; identical record shape on the DraftKings side.
- [**🏟️ ESPN Sports Data Scraper**](https://apify.com/parseforge/espn-sports-scraper) - schedules, scores, and team metadata to enrich your odds rows.
- [**🎟️ StubHub Scraper**](https://apify.com/parseforge/stubhub-scraper) - real-time event ticket pricing for the same games you're tracking.
- [**🎫 Ticketmaster Scraper**](https://apify.com/parseforge/ticketmaster-scraper) - primary-market event listings for cross-referencing tip-offs and start times.
- [**📅 Eventbrite Event Scraper**](https://apify.com/parseforge/eventbrite-scraper) - a broader event feed for sports-adjacent venue research.

> 💡 Pro Tip: browse the complete [ParseForge collection](https://apify.com/parseforge) for more sports, ticketing, and finance scrapers.

***

**🆘 Need Help?** Hit a snag, found a missing market, or have a feature request? [**Open our contact form**](https://tally.so/r/BzdKgA) and we will get back to you within one business day.

***

> Disclaimer: This Actor is an independent tool that reads publicly available data published on FanDuel's website. It is not affiliated with, endorsed by, or sponsored by FanDuel or its parent companies. All trademarks belong to their respective owners. Sports betting involves risk; this Actor is a data tool and is not a tipster, advisor, or guarantor of outcomes. Use the data in compliance with applicable laws and the source site's terms of service.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `sport` (type: `string`):

Sport league to scrape. ALL covers every supported league. NFL=American Football, NBA=Basketball, MLB=Baseball, NHL=Ice Hockey, MMA=Mixed Martial Arts, SOC=Soccer (every supported league worldwide), TEN=Tennis.

## `includeFutures` (type: `boolean`):

When enabled, the scraper also returns league-level futures (e.g. NBA Championship, NFL MVP, division winners) in addition to per-game lines. Futures markets list every contender with American and decimal odds.

## Actor input object example

```json
{
  "maxItems": 10,
  "sport": "ALL",
  "includeFutures": false
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fanduel-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/fanduel-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/fanduel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/fanduel-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FanDuel Sportsbook Odds Scraper",
        "description": "Scrape live FanDuel Sportsbook odds in real time: moneylines, spreads, totals, futures, and runners across NFL, NBA, MLB, NHL, MMA, soccer, and tennis.",
        "version": "1.0",
        "x-build-id": "nbVmhYQHI2LpuGXeX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~fanduel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-fanduel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~fanduel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-fanduel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~fanduel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-fanduel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sport": {
                        "title": "Sport",
                        "enum": [
                            "ALL",
                            "NFL",
                            "NBA",
                            "MLB",
                            "NHL",
                            "MMA",
                            "SOC",
                            "TEN"
                        ],
                        "type": "string",
                        "description": "Sport league to scrape. ALL covers every supported league. NFL=American Football, NBA=Basketball, MLB=Baseball, NHL=Ice Hockey, MMA=Mixed Martial Arts, SOC=Soccer (every supported league worldwide), TEN=Tennis.",
                        "default": "ALL"
                    },
                    "includeFutures": {
                        "title": "Include Futures & Outright Markets",
                        "type": "boolean",
                        "description": "When enabled, the scraper also returns league-level futures (e.g. NBA Championship, NFL MVP, division winners) in addition to per-game lines. Futures markets list every contender with American and decimal odds.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
