# TheSportsDB Scraper (`parseforge/thesportsdb-scraper`) Actor

Scrape leagues, teams, players, and events from TheSportsDB - the open sports database covering soccer, basketball, American football, baseball, ice hockey, and more. No API key required.

- **URL**: https://apify.com/parseforge/thesportsdb-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Business, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $26.25 / 1,000 results

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

Learn more: https://docs.apify.com/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://github.com/ParseForge/apify-assets/blob/main/banners/banner-default.jpg?raw=true)

## 🥅 TheSportsDB Scraper

> 🚀 **Export TheSportsDB's open sports catalogue in seconds.** Pull leagues, teams, players, upcoming and past events, league standings, and live scores across soccer, basketball, ice hockey, baseball, American football, and many more sports. No sign-up, no manual scraping, no setup.

> 🕒 **Last updated:** 2026-05-15 · **📊 30+ fields** per record · **🥅 Multi-sport coverage** · **🔍 10 lookup modes** · **🌐 Open community catalogue**

The **TheSportsDB Scraper** exports the crowd-sourced TheSportsDB catalogue and returns up to **30+ structured fields per record**. Whether you're pulling all leagues, searching for a team or player by name, fetching upcoming and past events for a league, looking up league standings, or grabbing live scores for a sport, the Actor returns a clean structured row per entity ready for your dataset.

The catalogue covers **soccer, basketball, American football, baseball, ice hockey, and many more sports**, with team metadata, player bios, league structure, fixture lists, standings tables, and a continuously updated live-scores feed. This is the friendliest open sports database on the web, packaged for one-click export.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports media, fantasy app developers, hobbyist sports devs, journalists, fan communities, indie analytics teams | Multi-sport league directories, team + player lookups, fixture feeds, standings widgets, live-score tickers, content automation |

---

### 📋 What the TheSportsDB Scraper does

Ten lookup modes in a single run:

- 🌍 **All Leagues.** Every league across every sport.
- 🏟️ **Team Search.** Resolve teams by name (e.g. "Arsenal").
- 🆔 **Team Lookup.** Resolve a team by canonical ID with full metadata.
- 👤 **Player Search.** Resolve players by name (e.g. "Messi").
- 📋 **Team Roster.** All players on a team by team ID.
- 📅 **Upcoming Events.** Next 15 events for a league by league ID.
- 🕓 **Past Events.** Last 15 events for a league by league ID.
- 📊 **Lookup Table.** League standings table for a season (e.g. `2024-2025`).
- 🔴 **Live Scores.** Live in-progress events by sport (e.g. Soccer, Basketball, Ice Hockey).
- 🗓️ **Events on a Day.** All matches on a specific date, optionally filtered by sport or league.

Each record is normalised: empty fields are stripped, every row carries a `scrapedAt` ISO 8601 timestamp, and the original TheSportsDB field names are preserved for direct join compatibility with the catalogue.

> 💡 **Why it matters:** TheSportsDB is one of the few free, multi-sport, multi-league databases on the web. Building your own pipeline against it means handling 10 different lookup endpoints, normalising responses, and refreshing data manually. This Actor packages all of that into one click.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>mode</code></td><td>string</td><td><code>"leagues"</code></td><td>One of <code>leagues</code>, <code>teamSearch</code>, <code>teamLookup</code>, <code>playerSearch</code>, <code>teamRoster</code>, <code>upcomingEvents</code>, <code>pastEvents</code>, <code>lookupTable</code>, <code>livescore</code>, <code>eventsday</code>.</td></tr>
<tr><td><code>query</code></td><td>string</td><td><code>""</code></td><td>Search text for teamSearch / playerSearch.</td></tr>
<tr><td><code>leagueId</code></td><td>string</td><td><code>""</code></td><td>League ID for upcomingEvents / pastEvents / lookupTable (e.g. 4328 = English Premier League).</td></tr>
<tr><td><code>teamId</code></td><td>string</td><td><code>""</code></td><td>Team ID for teamLookup / teamRoster.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>""</code></td><td>Season for lookupTable (e.g. <code>2024-2025</code>).</td></tr>
<tr><td><code>sport</code></td><td>string</td><td><code>""</code></td><td>Sport name for livescore / eventsday (e.g. <code>Soccer</code>, <code>Basketball</code>, <code>Ice_Hockey</code>).</td></tr>
<tr><td><code>date</code></td><td>string</td><td><code>""</code></td><td>YYYY-MM-DD for eventsday mode.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: every league in the catalogue.**

```json
{
    "mode": "leagues",
    "maxItems": 100
}
````

**Example: English Premier League standings table for 2024-2025.**

```json
{
    "mode": "lookupTable",
    "leagueId": "4328",
    "season": "2024-2025"
}
```

> ⚠️ **Good to Know:** TheSportsDB's free public tier returns a fixed page size (typically 10-15 items) for some endpoints. The `maxItems` input still applies on the dataset side for display purposes.

***

### 📊 Output

Each record contains up to **30+ fields**, depending on mode. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema (leagues mode example)

| Field | Type | Example |
|---|---|---|
| 🆔 `idLeague` | string | `"4328"` |
| 🏆 `strLeague` | string | `"English Premier League"` |
| ⚽ `strSport` | string | `"Soccer"` |
| 🔖 `strLeagueAlternate` | string | `"Premier League"` |
| 🔗 `slug` | string | `"english-premier-league-soccer"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |

#### 🧾 Schema (teamSearch / teamLookup mode)

| Field | Type | Example |
|---|---|---|
| 🆔 `idTeam` | string | `"133604"` |
| 🏟️ `strTeam` | string | `"Arsenal"` |
| 🏳️ `strCountry` | string | `"England"` |
| ⚽ `strSport` | string | `"Soccer"` |
| 🏆 `strLeague` | string | `"English Premier League"` |
| 📅 `intFormedYear` | string | `"1886"` |
| 🏟️ `strStadium` | string | `"Emirates Stadium"` |
| 🖼️ `strBadge` | string | `"https://www.thesportsdb.com/images/media/team/badge/..."` |
| 📝 `strDescriptionEN` | string | `"Arsenal Football Club is a..."` |

#### 📦 Sample record

<details>
<summary><strong>🥅 League: English Premier League</strong></summary>

```json
{
    "idLeague": "4328",
    "strLeague": "English Premier League",
    "strSport": "Soccer",
    "strLeagueAlternate": "Premier League",
    "slug": "english-premier-league-soccer",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🥅 | **Ten lookup modes.** Leagues, teams, players, fixtures, standings, live scores, day filters all in one Actor. |
| 🌐 | **Multi-sport coverage.** Soccer, basketball, American football, baseball, ice hockey, and more. |
| 🖼️ | **Rich media.** Team badges, stadium photos, player thumbs come straight from the catalogue. |
| 📅 | **Fixture feeds.** Next 15 + last 15 events per league, plus exact-date filters. |
| 📊 | **Standings tables.** Season-aware league tables with per-team metrics. |
| 🔁 | **Always fresh.** Every run pulls the latest catalogue state. |
| 🚫 | **No sign-up.** Works against the public catalogue. No login or token required. |

> 📊 TheSportsDB is the open multi-sport reference of choice for indie devs, fantasy startups, and fan-engagement platforms.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ TheSportsDB Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **Multi-sport**, 10 modes | **Live per run** | mode, query, league, team, sport, date | ⚡ 2 min |
| Commercial sports data vendors | $$$$/month | Full + extras | Streaming | Many | ⏳ Weeks |
| Manual scraping | Free | Inconsistent | On demand | None | 🐢 Days |
| Sport-specific scrapers | Free | Single league | Live | Limited | 🕒 Variable |

Pick this Actor when you want broad multi-sport coverage, normalised records, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the TheSportsDB Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode and supply the relevant inputs (league ID, team ID, query, or date).
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

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

#### 📺 Sports Media & Publishing

- Multi-sport content directories
- Auto-write article previews from upcoming-event feeds
- Live-score tickers across multiple leagues
- Daily fixture digests for newsletter automation

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

#### 🎲 Fantasy & Indie Sports Apps

- Cross-league fantasy product seeding
- Roster catalogue caches with badges and bios
- League standings widgets refreshed nightly
- Player search-as-you-type backed by real data

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

#### 🏟️ Fan Communities & Discord Bots

- Multi-sport "what's on tonight" channel posts
- Team-badge gallery commands for fan servers
- Postseason bracket dashboards
- Live-score push notifications

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

#### 📊 Analytics & Research

- Cross-sport calendar studies
- League-structure datasets for academic research
- Multi-league benchmark comparisons
- Time-series pulls for sports-econ projects

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

***

### 🔌 Automating TheSportsDB Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Refresh live scores every minute, daily fixture digests, or weekly league snapshots are all one click.

***

### 🌟 Beyond business use cases

Multi-sport data powers more than commercial workflows. The same records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Cross-sport coursework with real catalogue data
- Comparative league-structure studies
- Sport-history dissertations grounded in standings
- Reproducible research pulls with cited timestamps

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

#### 🎨 Personal and creative

- Hobbyist multi-sport tracker dashboards
- Discord bots for fan communities
- Trading-card generators with team badges
- Creator content automation across leagues

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

#### 🤝 Non-profit and civic

- Local-league publicity dashboards
- Sport-journalism for local newsrooms
- Inclusion analyses across player rosters
- Open-data hackathons on world-sport coverage

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

#### 🧪 Experimentation

- Train cross-sport schedule models
- Prototype agent pipelines that resolve team IDs
- Validate fan-product hypotheses with real fixtures
- Test live-stream UX concepts with real scores

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

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20TheSportsDB%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20TheSportsDB%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20TheSportsDB%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20TheSportsDB%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a mode (one of the ten lookup modes), supply the relevant inputs, and click Start. The Actor pulls fresh records from the public TheSportsDB catalogue and emits a clean structured row per league, team, player, or event.

#### 🥅 Which sports are covered?

Soccer, basketball, American football, baseball, ice hockey, and many more. Use the `leagues` mode to inspect every sport and league the catalogue knows about.

#### 📅 Can I get a fixture list for a league?

Yes. Set `mode` to `upcomingEvents` (next 15 fixtures) or `pastEvents` (last 15 fixtures) and supply the `leagueId` (e.g. `4328` for the English Premier League).

#### 📊 How do I get a league standings table?

Set `mode` to `lookupTable`, supply `leagueId`, and set `season` to a season string (e.g. `2024-2025`). Leave `season` empty to get the current season.

#### 🔴 Can I pull live scores?

Yes. Set `mode` to `livescore` and supply the `sport` name (e.g. `Soccer`, `Basketball`, `Ice_Hockey`). The Actor returns all in-progress events for that sport.

#### 🗓️ Can I get matches on a specific date?

Yes. Set `mode` to `eventsday`, supply `date` as `YYYY-MM-DD`, and optionally narrow by `sport` or `leagueId`.

#### 🔍 How do I look up a team or player?

Use `teamSearch` or `playerSearch` and supply the name in `query` (e.g. `"Arsenal"`, `"Messi"`). Use `teamLookup` or `teamRoster` if you already have the canonical ID.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor every minute, hourly, or daily. The dataset always reflects the current state of the public catalogue.

#### ⚖️ Is this data legal to use?

The TheSportsDB catalogue is published as an open community dataset. Review the source's terms of use for your specific use case, particularly if you redistribute or commercialise the content.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling and higher concurrency.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

TheSportsDB Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get score updates in your channels
- [**n8n**](https://docs.apify.com/platform/integrations/n8n) - Self-hosted workflow automation
- [**Pipedream**](https://docs.apify.com/platform/integrations/pipedream) - Event-driven serverless workflows
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe sports data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh fixtures into your product backend, or alert your fans in Slack when a goal is scored.

***

### 🔗 Recommended Actors

- [**🏆 Sofascore Live Events Scraper**](https://apify.com/parseforge/sofascore-live-scraper) - 13-sport live + scheduled events feed
- [**⚾ MLB Stats Scraper**](https://apify.com/parseforge/mlb-stats-scraper) - Schedules, teams, rosters, player stats, live game feeds
- [**🏒 NHL Stats Scraper**](https://apify.com/parseforge/nhl-stats-scraper) - 32-team standings, schedules, player landing
- [**🛡️ CWE MITRE Scraper**](https://apify.com/parseforge/cwe-mitre-scraper) - Software weakness reference catalogue
- [**📊 OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport reference dataset

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by TheSportsDB or any of its contributors. All trademarks mentioned are the property of their respective owners. Only publicly available open sports catalogue data is collected.

# Actor input Schema

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

Which TheSportsDB lookup to run. Note: results are limited by the source provider (typically 10-15 per request on the public tier).

## `query` (type: `string`):

Search text for teamSearch / playerSearch modes (e.g. 'Arsenal', 'Messi').

## `leagueId` (type: `string`):

League ID for upcomingEvents / pastEvents (e.g. 4328 = English Premier League).

## `teamId` (type: `string`):

Team ID for teamLookup / teamRoster modes.

## `season` (type: `string`):

Season for lookupTable mode (e.g. '2024-2025'). Optional; if empty TheSportsDB returns the current season.

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

Sport name for livescore / eventsday modes (e.g. 'Soccer', 'Basketball', 'Ice\_Hockey', 'American Football').

## `date` (type: `string`):

Date for eventsday mode (e.g. '2025-05-14').

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

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

## Actor input object example

```json
{
  "mode": "leagues",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "leagues",
    "query": "",
    "leagueId": "",
    "teamId": "",
    "season": "",
    "sport": "",
    "date": "",
    "maxItems": 10
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "leagues",
    "query": "",
    "leagueId": "",
    "teamId": "",
    "season": "",
    "sport": "",
    "date": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/thesportsdb-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 '{
  "mode": "leagues",
  "query": "",
  "leagueId": "",
  "teamId": "",
  "season": "",
  "sport": "",
  "date": "",
  "maxItems": 10
}' |
apify call parseforge/thesportsdb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TheSportsDB Scraper",
        "description": "Scrape leagues, teams, players, and events from TheSportsDB - the open sports database covering soccer, basketball, American football, baseball, ice hockey, and more. No API key required.",
        "version": "0.0",
        "x-build-id": "ext1igvmSrYBiVMaj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~thesportsdb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-thesportsdb-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~thesportsdb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-thesportsdb-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~thesportsdb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-thesportsdb-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "leagues",
                            "teamSearch",
                            "teamLookup",
                            "playerSearch",
                            "teamRoster",
                            "upcomingEvents",
                            "pastEvents",
                            "lookupTable",
                            "livescore",
                            "eventsday"
                        ],
                        "type": "string",
                        "description": "Which TheSportsDB lookup to run. Note: results are limited by the source provider (typically 10-15 per request on the public tier).",
                        "default": "leagues"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search text for teamSearch / playerSearch modes (e.g. 'Arsenal', 'Messi')."
                    },
                    "leagueId": {
                        "title": "League ID",
                        "type": "string",
                        "description": "League ID for upcomingEvents / pastEvents (e.g. 4328 = English Premier League)."
                    },
                    "teamId": {
                        "title": "Team ID",
                        "type": "string",
                        "description": "Team ID for teamLookup / teamRoster modes."
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Season for lookupTable mode (e.g. '2024-2025'). Optional; if empty TheSportsDB returns the current season."
                    },
                    "sport": {
                        "title": "Sport",
                        "type": "string",
                        "description": "Sport name for livescore / eventsday modes (e.g. 'Soccer', 'Basketball', 'Ice_Hockey', 'American Football')."
                    },
                    "date": {
                        "title": "Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Date for eventsday mode (e.g. '2025-05-14')."
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
