# Sports Betting Odds Scraper — Live Lines by Bookmaker (`sian.agency/sports-betting-odds-scraper`) Actor

Pull live sports betting odds from 8+ bookmakers in one run — moneyline, spreads and totals for NFL, NBA, MLB, NHL, soccer and more. One row per bookmaker line, plus live scores and a sports directory. American or decimal odds, US/UK/EU/AU regions. Export JSON, CSV or Excel.

- **URL**: https://apify.com/sian.agency/sports-betting-odds-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Sports, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 odds line extracteds

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

## Sports Betting Odds Scraper — Live Lines by Bookmaker 🎲

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Jobs Search API](https://img.shields.io/badge/Store-Jobs%20Search%20API-1AE392)](https://apify.com/sian.agency/jsearch-jobs-scraper?fpr=sian) [![Taobao Tmall Product Scraper](https://img.shields.io/badge/Store-Taobao%20Tmall%20Product-FF4F00)](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [![Xiaohongshu RedNote Scraper](https://img.shields.io/badge/Store-Xiaohongshu%20RedNote-FF2442)](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian)

#### 🎉 The whole board in one run — 8+ bookmakers, every market, every in-season sport
##### Built for line shoppers, arbitrage hunters, model builders, and anyone feeding odds into apps or spreadsheets

---

### 📋 Overview

**Stop scraping one sportsbook at a time.** The Sports Betting Odds Scraper pulls live betting odds from 8+ bookmakers in a single run — moneyline, spreads and totals for NFL, NBA, MLB, NHL, soccer and dozens more leagues — and hands you one clean row per bookmaker line.

**Why data teams and bettors choose us:**
- ✅ **8+ bookmakers in one feed**: FanDuel, DraftKings, BetMGM, Caesars, Bovada, BetRivers, BetUS and BetOnline.ag side by side — not a single-book scraper
- ⚡ **`upcoming` cross-sport sweep**: one run returns the next games across every in-season sport — no need to loop sport by sport
- 🎯 **Every market, with the line**: moneyline (h2h), point spreads and totals (over/under) — each row carries the exact handicap or total
- 💰 **Pay only for the lines you pull**: transparent per-line pricing, a generous free tier, and no monthly subscription lock-in
- 💎 **American or decimal, US/UK/EU/AU**: switch odds format and bookmaker region to match your market
- ✨ **Three tools in one**: live odds, live scores, and a sports directory — all in a single actor

---

### ✨ Features

- 🎲 **Multi-Bookmaker Odds**: every bookmaker's price for the same game, one flat row each — perfect for line shopping
- 🏈 **All Major Sports**: NFL, NBA, MLB, NHL, NCAA, soccer (EPL, La Liga, MLS…), MMA, tennis and more
- 🔀 **`upcoming` Sweep**: pull the next games across all in-season sports in a single call
- 📊 **Three Markets**: moneyline, spreads and totals — each with the point/handicap line attached
- 🔢 **Odds Format Toggle**: American (-110, +250) or decimal (1.91, 3.50)
- 🌍 **Region Toggle**: US, US (extra), UK, EU and Australian bookmakers
- 🏁 **Live & Recent Scores**: final and in-play scores for any sport
- 📚 **Sports Directory**: discover the exact sport key for any league before you pull
- 📤 **Export Anywhere**: JSON, CSV or Excel straight from the dataset

---

### 🎬 Quick Start

Pick an operation, pick a sport (or `upcoming`), and run. Each run produces one clean dataset you can export to JSON, CSV or Excel. Start with the **Sports Directory** operation to find sport keys, then pull **Live Odds**.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~sports-betting-odds-scraper/runs?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"operation": "odds", "sport": "upcoming", "regions": ["us"], "markets": ["h2h","spreads","totals"], "oddsFormat": "american"}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your operation

Select **Live Odds**, **Scores**, or **Sports Directory**.

#### Step 2: Set the sport and markets

Enter a sport key (or `upcoming` to sweep all in-season sports) and pick your regions, markets and odds format.

#### Step 3: Run and export

Start the run and export the dataset to JSON, CSV or Excel.

**That's it! In under a minute, you'll have:**

- Live lines from 8+ bookmakers, one row each
- The exact spread/total line on every row
- A clean, joinable dataset keyed by event ID

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | string | Yes | `odds`, `scores`, or `sports` |
| sport | string | No | Sport key (e.g. `americanfootball_nfl`) or `upcoming` for all in-season sports. Used by Live Odds & Scores |
| regions | array | No | Bookmaker regions for Live Odds: `us`, `us2`, `uk`, `eu`, `au` (default `us`) |
| markets | array | No | Markets for Live Odds: `h2h`, `spreads`, `totals`, `outrights` (default `h2h`) |
| oddsFormat | string | No | `american` or `decimal` (default `american`) |
| daysFrom | integer | No | Scores: days of completed games to include, 1–3 (default 1) |

**Example — Live Odds (all markets, US books):**

```json
{
  "operation": "odds",
  "sport": "americanfootball_nfl",
  "regions": ["us"],
  "markets": ["h2h", "spreads", "totals"],
  "oddsFormat": "american"
}
```

**Example — Sports Directory:**

```json
{ "operation": "sports" }
```

**Example — Scores:**

```json
{ "operation": "scores", "sport": "americanfootball_nfl", "daysFrom": 2 }
```

***

### 📤 Output

Results are saved to the Apify dataset as flat rows. **Live Odds** emits one row per event × bookmaker × market × outcome:

| Field | Type | Description |
|-------|------|-------------|
| eventId | string | Stable event ID (join scores to odds on this) |
| sportTitle | string | League name (NFL, NBA…) |
| commenceTime | string | Scheduled start time (UTC, ISO-8601) |
| homeTeam / awayTeam | string | The two teams |
| bookmaker | string | Bookmaker name (FanDuel, DraftKings…) |
| market | string | Moneyline, Spread or Total |
| outcomeName | string | The priced side — a team, Over or Under |
| price | string | The offered price (American or decimal) |
| point | string | Spread handicap or total line (empty for moneyline) |
| lastUpdate | string | When the bookmaker last moved this market |

**Example row:**

```json
{
  "_operation": "odds",
  "eventId": "4bb2c510f37ac3221423f6fe96d81822",
  "sportKey": "americanfootball_nfl",
  "sportTitle": "NFL",
  "commenceTime": "2026-09-10T00:15:00Z",
  "homeTeam": "Seattle Seahawks",
  "awayTeam": "New England Patriots",
  "bookmaker": "FanDuel",
  "market": "Spread",
  "outcomeName": "Seattle Seahawks",
  "price": "-110",
  "point": "-7.5",
  "lastUpdate": "2026-06-21T03:11:04Z",
  "status": "success"
}
```

**Scores** rows carry `homeScore`/`awayScore`/`completed`; **Sports Directory** rows carry `sportKey`/`sportGroup`/`active`/`hasOutrights`.

***

### 💼 Use Cases & Examples

#### 1. Odds Comparison & Line Shopping

**Bettors and tipsters who want the best number on every game.**

**Input:** `operation: odds`, `sport: upcoming`, all markets
**Output:** every bookmaker's price for each line, one row each
**Use:** sort by price to find the sportsbook offering the best value on any side.

#### 2. Arbitrage & Middling Research

**Quants hunting for risk-free or low-risk edges.**

**Input:** multiple regions (`us`, `uk`, `eu`) across all markets
**Output:** the full board where books disagree on a line
**Use:** detect arbitrage and middling opportunities across bookmakers.

#### 3. Model & Prediction Backtesting

**Data scientists building betting models.**

**Input:** scheduled runs capturing lines over time with timestamps
**Output:** a time series of odds movement keyed by event ID
**Use:** backtest strategies and study closing-line value.

#### 4. Live Scores Tracking

**App and dashboard builders.**

**Input:** `operation: scores`, any sport
**Output:** final and in-play scores
**Use:** settle results, power live dashboards, or join scores to your odds dataset.

#### 5. Sports Data Feeds for Apps

**Developers wiring odds into products with no code.**

**Input:** Sports Directory to discover keys, then scheduled odds runs
**Output:** clean structured feeds
**Use:** push odds and scores into apps, spreadsheets and BI tools as a no-code pipeline.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/sports-betting-odds-scraper').call({
  operation: 'odds',
  sport: 'upcoming',
  regions: ['us'],
  markets: ['h2h', 'spreads', 'totals'],
  oddsFormat: 'american'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/sports-betting-odds-scraper').call(
    run_input={
        'operation': 'odds',
        'sport': 'americanfootball_nfl',
        'regions': ['us'],
        'markets': ['h2h', 'spreads', 'totals'],
        'oddsFormat': 'american'
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~sports-betting-odds-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "odds", "sport": "upcoming", "markets": ["h2h"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. every 5 minutes pre-game)
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON odds rows
4. **Action**: Save to a database, alert on line moves, or update a sheet

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **50 rows** per run — full feature access, same data quality
- No credit card required
- Perfect for testing a sport, market or region

#### PAID Tier (Production Ready)

- **Unlimited** rows per run
- The whole board across every book and market
- Pay-per-line: only charged for lines actually returned

💰 **Priced at the market rate** for a multi-bookmaker feed — wider coverage than single-book scrapers at the same per-line cost.

🔗 [View current pricing](https://apify.com/sian.agency/sports-betting-odds-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: Which bookmakers are covered?**
A: 8+ US books including FanDuel, DraftKings, BetMGM, Caesars, Bovada, BetRivers, BetUS and BetOnline.ag, plus UK/EU/AU books via the region toggle.

**Q: How do I get every sport at once?**
A: Set `sport` to `upcoming` — one run returns the next games across all in-season sports.

**Q: Why did a single sport return no rows?**
A: That league is likely out of season. Use `upcoming` to sweep whatever is currently in season.

**Q: American or decimal odds?**
A: Both — set `oddsFormat` to `american` or `decimal`.

**Q: What output formats are available?**
A: JSON, CSV and Excel — export directly from the Apify dataset.

**Q: Can I join scores to odds?**
A: Yes — both share the same `eventId`.

**Q: How often do odds update?**
A: Lines reflect the latest published prices; each row carries a `lastUpdate` timestamp. Schedule runs to capture movement.

***

### 🐛 Troubleshooting

**No rows returned**

- The sport may be out of season — try `sport: upcoming`
- Double-check the sport key via the **Sports Directory** operation

**Fewer rows than expected**

- On the FREE tier output is capped at 50 rows — upgrade for the full board
- Add more markets (`spreads`, `totals`) or regions to widen coverage

**Missing the spread/total line**

- The `point` field is only populated for `spreads` and `totals`, never for moneyline (`h2h`)

***

### ⚠️ Responsible Use

This tool returns sports betting odds **for data, research and informational purposes only**. It is **not betting advice** and does not facilitate the placement of bets. Sports betting may be **restricted or illegal** in your jurisdiction — you are responsible for complying with all applicable laws. You must be of legal gambling age (**18+, or 21+ where required**). If you or someone you know has a gambling problem, help is available: call **1-800-GAMBLER** (US) or contact your local support service.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what has been chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Console Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🎲 Live Odds** — moneyline, spreads and totals for a sport, one row per bookmaker line (the main mode)
- **🏁 Scores** — live & recent game scores for a sport (final and in-play)
- **📚 Sports Directory** — the list of available sports and leagues with their keys

💡 **TIP:** Run **Sports Directory** first to discover the exact sport key, then use it in **Live Odds** or **Scores**. Use `upcoming` as the sport to sweep the next games across all in-season sports in one run.

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

🏈 **The sport / league to pull (Live Odds & Scores).** Use a key from the Sports Directory operation — e.g. `americanfootball_nfl`, `basketball_nba`, `baseball_mlb`, `icehockey_nhl`, `soccer_epl`.

💡 Use **`upcoming`** to get the next games across ALL in-season sports in one run (recommended starting point).

⚠️ Ignored for the **Sports Directory** operation.

## `regions` (type: `array`):

🌍 **Bookmaker regions to include (Live Odds).** Each region adds its bookmakers' lines.

- **us** — major US books (FanDuel, DraftKings, BetMGM, Caesars…)
- **us2** — additional US books
- **uk / eu / au** — UK, European & Australian books

Leave default (`us`) for US sportsbooks.

## `markets` (type: `array`):

📊 **Bet markets to include (Live Odds).**

- **h2h** — moneyline (win/lose)
- **spreads** — point spreads (with the handicap line)
- **totals** — over/under (with the total line)
- **outrights** — futures / tournament winners (where offered)

Each added market multiplies the number of rows returned.

## `oddsFormat` (type: `string`):

🔢 **How prices are expressed (Live Odds).** `american` (e.g. -110, +250) or `decimal` (e.g. 1.91, 3.50).

## `daysFrom` (type: `integer`):

🗓️ **How many days of completed games to include (Scores).** `1`–`3`. Upcoming games are always included; this only widens the recent-results window.

## Actor input object example

```json
{
  "operation": "odds",
  "sport": "upcoming",
  "regions": [
    "us"
  ],
  "markets": [
    "h2h",
    "spreads",
    "totals"
  ],
  "oddsFormat": "american",
  "daysFrom": 1
}
```

# Actor output Schema

## `output` (type: `string`):

Sports betting odds, scores, or the sports directory — one flat row per bookmaker line (event × bookmaker × market × outcome) for odds, with curated camelCase fields (sportKey, homeTeam, awayTeam, bookmaker, market, outcomeName, price, point, …).

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, upstream calls, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "sport": "upcoming",
    "regions": [
        "us"
    ],
    "markets": [
        "h2h",
        "spreads",
        "totals"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/sports-betting-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 = {
    "sport": "upcoming",
    "regions": ["us"],
    "markets": [
        "h2h",
        "spreads",
        "totals",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/sports-betting-odds-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 '{
  "sport": "upcoming",
  "regions": [
    "us"
  ],
  "markets": [
    "h2h",
    "spreads",
    "totals"
  ]
}' |
apify call sian.agency/sports-betting-odds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sports Betting Odds Scraper — Live Lines by Bookmaker",
        "description": "Pull live sports betting odds from 8+ bookmakers in one run — moneyline, spreads and totals for NFL, NBA, MLB, NHL, soccer and more. One row per bookmaker line, plus live scores and a sports directory. American or decimal odds, US/UK/EU/AU regions. Export JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "KmBFqBs08WeIZiRxj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~sports-betting-odds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-sports-betting-odds-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/sian.agency~sports-betting-odds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-sports-betting-odds-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/sian.agency~sports-betting-odds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-sports-betting-odds-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",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to pull?",
                        "enum": [
                            "odds",
                            "scores",
                            "sports"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🎲 Live Odds** — moneyline, spreads and totals for a sport, one row per bookmaker line (the main mode)\n- **🏁 Scores** — live & recent game scores for a sport (final and in-play)\n- **📚 Sports Directory** — the list of available sports and leagues with their keys\n\n💡 **TIP:** Run **Sports Directory** first to discover the exact sport key, then use it in **Live Odds** or **Scores**. Use `upcoming` as the sport to sweep the next games across all in-season sports in one run.",
                        "default": "odds"
                    },
                    "sport": {
                        "title": "🏈 Sport key",
                        "type": "string",
                        "description": "🏈 **The sport / league to pull (Live Odds & Scores).** Use a key from the Sports Directory operation — e.g. `americanfootball_nfl`, `basketball_nba`, `baseball_mlb`, `icehockey_nhl`, `soccer_epl`.\n\n💡 Use **`upcoming`** to get the next games across ALL in-season sports in one run (recommended starting point).\n\n⚠️ Ignored for the **Sports Directory** operation.",
                        "default": "upcoming"
                    },
                    "regions": {
                        "title": "🌍 Regions (Live Odds)",
                        "type": "array",
                        "description": "🌍 **Bookmaker regions to include (Live Odds).** Each region adds its bookmakers' lines.\n\n- **us** — major US books (FanDuel, DraftKings, BetMGM, Caesars…)\n- **us2** — additional US books\n- **uk / eu / au** — UK, European & Australian books\n\nLeave default (`us`) for US sportsbooks.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "us",
                                "us2",
                                "uk",
                                "eu",
                                "au"
                            ],
                            "enumTitles": [
                                "US",
                                "US (extra)",
                                "UK",
                                "EU",
                                "Australia"
                            ]
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "markets": {
                        "title": "📊 Markets (Live Odds)",
                        "type": "array",
                        "description": "📊 **Bet markets to include (Live Odds).**\n\n- **h2h** — moneyline (win/lose)\n- **spreads** — point spreads (with the handicap line)\n- **totals** — over/under (with the total line)\n- **outrights** — futures / tournament winners (where offered)\n\nEach added market multiplies the number of rows returned.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "h2h",
                                "spreads",
                                "totals",
                                "outrights"
                            ],
                            "enumTitles": [
                                "Moneyline (h2h)",
                                "Spreads",
                                "Totals (O/U)",
                                "Outrights / Futures"
                            ]
                        },
                        "default": [
                            "h2h"
                        ]
                    },
                    "oddsFormat": {
                        "title": "🔢 Odds format (Live Odds)",
                        "enum": [
                            "american",
                            "decimal"
                        ],
                        "type": "string",
                        "description": "🔢 **How prices are expressed (Live Odds).** `american` (e.g. -110, +250) or `decimal` (e.g. 1.91, 3.50).",
                        "default": "american"
                    },
                    "daysFrom": {
                        "title": "🗓️ Days back (Scores)",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "🗓️ **How many days of completed games to include (Scores).** `1`–`3`. Upcoming games are always included; this only widens the recent-results window.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
