# Cricsheet Cricket Match Data Scraper (`parseforge/cricsheet-scraper`) Actor

Scrape cricket match data from Cricsheet including Test, ODI, T20I, IPL, BBL, PSL, CPL, The Hundred and more. Returns structured match metadata: teams, winner, venue, toss, player-of-match. No API key required.

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

## Pricing

from $30.00 / 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)

## 🏏 Cricsheet Cricket Match Data Scraper

> 🚀 **Export cricket match data in seconds.** Pull match summaries or **per-ball delivery records** for **15,000+ matches** across Test, ODI, T20I, IPL, BBL, PSL, CPL, The Hundred, WPL, and World Cups. No sign-up needed.

> 🕒 **Last updated:** 2026-05-15 · **📊 28 fields** per match · **🏏 15,000+ matches** · **🌍 16 formats and leagues** · **📅 Decades of historical archive**

The **Cricsheet Scraper** pulls structured match records from Cricsheet, the open-source cricket data archive used by analysts, fantasy-cricket developers, and academics worldwide. Two modes share a single input form: **matches** (one row per match with summary plus aggregate stats) or **deliveries** (one row per ball with batter, bowler, runs, and wicket info, the format that makes Cricsheet uniquely valuable).

Coverage spans **15,000+ matches across 16 formats and leagues**: Tests, ODIs, T20Is, IPL, BBL, PSL, CPL, The Hundred, WBBL, WPL, SA20, ILT20, World Cups (men and women), other multi-day, and other one-day cricket. Filter by team, season, gender, or venue and download as CSV, Excel, JSON, or XML in under three minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Fantasy-cricket developers, sports analysts, betting modellers, academic researchers, broadcasters, app developers, podcast statisticians | Player performance modelling, ball-by-ball replay generators, T20 win-probability models, fantasy scoring engines, historical archive apps |

---

### 📋 What the Cricsheet Scraper does

Six filtering inputs combine in a single run:

- 📊 **Output mode.** Match summaries (one row per match) or per-ball deliveries (one row per ball, the headline value of Cricsheet).
- 🏆 **Match type / league.** Tests, ODIs, T20Is, IPL, BBL, PSL, CPL, The Hundred, WBBL, WPL, SA20, ILT20, multi-day, one-day, World Cups, or "recently added" for the latest 30.
- 🏏 **Team filter.** Case-insensitive substring match on team name.
- 📅 **Season filter.** Restrict to a specific season or year (e.g. `2024`, `2023/24`).
- 🚹 **Gender filter.** Men's, women's, or both.
- 🏟️ **Venue filter.** Case-insensitive substring match on venue (e.g. `Eden Gardens`).

Match-summary records carry teams, winner, win margin (runs/wickets/innings), result, toss winner and decision, player of the match, total runs scored across innings, total wickets, and run rate per over. Per-ball delivery records carry batter, bowler, non-striker, runs scored, extras type, boundary flag, wicket flag, dismissal kind, and player out.

> 💡 **Why it matters:** Cricsheet's per-ball data unlocks ball-by-ball win-probability models, fantasy scoring engines, and replay generators. Building this pipeline yourself means downloading per-format archives, unpacking JSONs, and writing per-format parsers. This Actor handles it all on every run.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>string</td><td><code>"matches"</code></td><td><code>matches</code> = one row per match. <code>deliveries</code> = one row per ball.</td></tr>
<tr><td><code>matchType</code></td><td>string</td><td><code>"recently_added_30"</code></td><td>Cricket format or league (Tests, ODIs, T20Is, IPL, BBL, PSL, CPL, The Hundred, WBBL, WPL, SA20, ILT20, World Cups, or recently added).</td></tr>
<tr><td><code>team</code></td><td>string</td><td><code>""</code></td><td>Team name substring filter.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>""</code></td><td>Season or year filter (e.g. <code>2024</code>, <code>2023/24</code>).</td></tr>
<tr><td><code>gender</code></td><td>string</td><td><code>""</code></td><td>One of empty (both), <code>male</code>, <code>female</code>.</td></tr>
<tr><td><code>venue</code></td><td>string</td><td><code>""</code></td><td>Venue name substring filter.</td></tr>
</tbody>
</table>

**Example: 50 most-recent IPL match summaries.**

```json
{
    "maxItems": 50,
    "mode": "matches",
    "matchType": "ipl"
}
````

**Example: every ball bowled by India in 2024 World Cup matches.**

```json
{
    "maxItems": 5000,
    "mode": "deliveries",
    "matchType": "wc",
    "team": "India",
    "season": "2024"
}
```

> ⚠️ **Good to Know:** the deliveries mode emits one row per ball (typically 240 rows per T20 innings, up to 540 per ODI innings, several thousand for a Test). Set `maxItems` accordingly. The Cricsheet archive is contributor-driven, so very recent fixtures may take a few days to appear. Older matches may have varying levels of detail.

***

### 📊 Output

Match-summary records contain **28 fields**. Per-ball delivery records contain **17 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Match summary schema

| Field | Type | Example |
|---|---|---|
| 🆔 `match_id` | string | `"1426294"` |
| 📅 `match_date` | string | null | `"2024-05-26"` |
| 📅 `match_dates` | array | `["2024-05-26"]` |
| 🏆 `match_type` | string | null | `"T20"` |
| 🏷️ `match_type_number` | number | null | `74` |
| 🚹 `gender` | string | null | `"male"` |
| 👥 `team_type` | string | null | `"club"` |
| 🏟️ `venue` | string | null | `"M Chinnaswamy Stadium"` |
| 🏙️ `city` | string | null | `"Bengaluru"` |
| 🏆 `event_name` | string | null | `"Indian Premier League"` |
| 🔢 `event_match_number` | number | null | `74` |
| 🎫 `event_group` | string | null | `null` |
| 📅 `season` | string | null | `"2024"` |
| ⚪ `overs` | number | null | `20` |
| ⚪ `balls_per_over` | number | null | `6` |
| 👥 `teams` | array | `["Kolkata Knight Riders","Sunrisers Hyderabad"]` |
| 🥇 `winner` | string | null | `"Kolkata Knight Riders"` |
| 🏃 `win_by_runs` | number | null | `null` |
| 🎯 `win_by_wickets` | number | null | `8` |
| 🎲 `toss_winner` | string | null | `"Sunrisers Hyderabad"` |
| 🪙 `toss_decision` | string | null | `"bat"` |
| 🏅 `player_of_match` | array | `["MA Starc"]` |
| 🎯 `totalRunsScored` | number | `227` |
| 🎯 `totalWickets` | number | `9` |
| 📊 `runRatePerOver` | number | null | `7.566` |
| 🔗 `url` | string | `"https://cricsheet.org/downloads/..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |

#### 🧾 Per-ball delivery schema

| Field | Type | Example |
|---|---|---|
| 🆔 `match_id` | string | `"1426294"` |
| 🔢 `innings` | number | `1` |
| 🏏 `batting_team` | string | `"Kolkata Knight Riders"` |
| ⚪ `over` | number | `0` |
| ⚪ `ball` | number | `1` |
| 🏏 `batter` | string | `"SP Narine"` |
| 🎯 `bowler` | string | `"B Kumar"` |
| 🏏 `non_striker` | string | `"PD Salt"` |
| 🎯 `runs_batter` | number | `4` |
| 🎯 `runs_extras` | number | `0` |
| 🎯 `runs_total` | number | `4` |
| 🚩 `extras_type` | string | null | `null` |
| 🎯 `isBoundary` | boolean | `true` |
| 🎯 `isWicket` | boolean | `false` |
| ❌ `wicket_kind` | string | null | `null` |
| ❌ `player_out` | string | null | `null` |
| 🔗 `url` | string | `"https://cricsheet.org/downloads/..."` |

#### 📦 Sample records

<details>
<summary><strong>🏆 IPL 2024 final: KKR vs SRH match summary</strong></summary>

```json
{
    "match_id": "1426294",
    "match_date": "2024-05-26",
    "match_dates": ["2024-05-26"],
    "match_type": "T20",
    "gender": "male",
    "venue": "M Chinnaswamy Stadium",
    "city": "Bengaluru",
    "event_name": "Indian Premier League",
    "event_match_number": 74,
    "season": "2024",
    "overs": 20,
    "balls_per_over": 6,
    "teams": ["Kolkata Knight Riders","Sunrisers Hyderabad"],
    "winner": "Kolkata Knight Riders",
    "win_by_wickets": 8,
    "toss_winner": "Sunrisers Hyderabad",
    "toss_decision": "bat",
    "player_of_match": ["MA Starc"],
    "totalRunsScored": 227,
    "totalWickets": 9,
    "runRatePerOver": 7.566,
    "url": "https://cricsheet.org/downloads/1426294.json",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏏 First ball of the same match (deliveries mode)</strong></summary>

```json
{
    "match_id": "1426294",
    "innings": 1,
    "batting_team": "Sunrisers Hyderabad",
    "over": 0,
    "ball": 1,
    "batter": "Abhishek Sharma",
    "bowler": "VR Iyer",
    "non_striker": "TM Head",
    "runs_batter": 0,
    "runs_extras": 0,
    "runs_total": 0,
    "extras_type": null,
    "isBoundary": false,
    "isWicket": false,
    "wicket_kind": null,
    "player_out": null,
    "url": "https://cricsheet.org/downloads/1426294.json",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏏 | **Per-ball detail.** Deliveries mode emits one row per ball with batter, bowler, runs, extras, and wicket info. The format that makes Cricsheet unique. |
| 🏆 | **16 formats and leagues.** Tests, ODIs, T20Is, IPL, BBL, PSL, CPL, The Hundred, WBBL, WPL, SA20, ILT20, multi-day, one-day, World Cups. |
| 🚹 | **Men's and women's cricket.** Full coverage of both with a single gender filter. |
| 📊 | **Pre-computed aggregates.** Match summaries include total runs, wickets, and run rate per over so you skip the per-ball roll-up. |
| 🥇 | **Outcomes and tosses.** Winner, win margin, toss winner, toss decision, and player of the match all structured. |
| ⚡ | **Fast.** Hundreds of match summaries in under a minute, multi-thousand delivery rows in seconds. |
| 🚫 | **No authentication.** Public Cricsheet open archive. No login or registration needed. |

> 🏏 Cricsheet is the most-cited open cricket dataset and is used by fantasy platforms, broadcasters, and academic studies worldwide.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Cricsheet Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **15,000+ matches, per-ball detail** | **Live per run** | format, team, season, gender, venue | ⚡ 2 min |
| Manual Cricsheet downloads | Free | All formats | Manual | Manual unzip + parse | 🐢 Hours per format |
| Commercial cricket-data feeds | $1,000+/month | Live + archive | Real-time | Many | ⏳ License + onboarding |
| Per-source scoreboard scraping | Free | One source | Per-page | Few | ⏳ Many parsers |

Pick this Actor when you want clean, structured, ball-by-ball cricket data without writing parsers.

***

### 🚀 How to use

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

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

***

### 💼 Business use cases

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

#### 🎮 Fantasy & Betting

- Fantasy scoring engines fed live by per-ball deliveries
- Win-probability models trained on historical T20 ball-by-ball
- Player-prop betting analytics across formats
- DFS lineup optimizers using per-batter-versus-bowler splits

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

#### 📺 Broadcast & Media

- Real-time graphics fed by structured match metadata
- "On this day" highlight segments from historical archive
- Statistical overlays for commentary and post-match analysis
- Newsroom backgrounders on player and team form

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

#### 📱 Apps & Products

- Cricket scoreboard apps with consistent format coverage
- Player career-history apps spanning men's and women's cricket
- League-comparison dashboards (IPL vs BBL vs PSL vs The Hundred)
- Replay-viewer apps powered by ball-by-ball delivery records

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

#### 🎓 Analytics & Coaching

- Team-performance analytics for coaching staff
- Opposition-scouting reports built from per-ball data
- Bowler-versus-batter matchup analyses
- Venue-effect studies (high-scoring vs low-scoring grounds)

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

***

### 🔌 Automating Cricsheet 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/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes during a tournament keep downstream cricket dashboards in sync automatically.

***

### 🌟 Beyond business use cases

Cricket data 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

- Sports-science papers on per-ball performance
- Reproducible studies with cited, versioned dataset pulls
- Statistics coursework using ball-by-ball data
- Open-data exercises on cricket history

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

#### 🎨 Personal and creative

- Personal stat-tracker projects for favourite teams
- Hobbyist analysis of niche leagues (BBL, ILT20, SA20)
- Cricket-blog charts and visualisations
- Indie cricket-games and simulators

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

#### 🤝 Non-profit and civic

- Grassroots-cricket development analytics
- Civic projects on women's cricket visibility
- Investigative journalism on match-fixing patterns
- Cricsheet community contributions

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

#### 🧪 Experimentation

- Train ML models for ball-outcome prediction
- Validate sports-tech product hypotheses with real data
- Prototype agent pipelines that resolve player and venue names
- Test dashboard concepts with live cricket feeds

</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%20Cricsheet%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%20Cricsheet%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%20Cricsheet%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%20Cricsheet%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 (matches or deliveries), choose a format or league, optionally filter by team, season, gender, or venue, click Start, and the Actor returns clean structured rows with full metadata or per-ball detail.

#### 🏏 What's the difference between matches and deliveries mode?

`matches` returns one row per match with summary fields and aggregate stats (total runs, wickets, run rate per over). `deliveries` returns one row per ball, with batter, bowler, runs, extras, boundary flag, wicket flag, and dismissal info. Choose deliveries for ball-by-ball modelling, matches for high-level summaries.

#### 🏆 Which formats and leagues are covered?

16 formats and leagues: Tests, ODIs, T20Is, IPL, BBL (Big Bash League), PSL (Pakistan Super League), CPL (Caribbean Premier League), The Hundred, WBBL (Women's Big Bash League), WPL (Women's Premier League), SA20, ILT20 (UAE), other multi-day cricket, other one-day cricket, and World Cups (men and women combined).

#### 🚹 Are women's matches included?

Yes. WBBL and WPL are dedicated leagues, and women's World Cup matches are included under the World Cup option. Use the `gender` filter to scope to men's-only or women's-only across any format.

#### 📅 How far back does the archive go?

Cricsheet has structured records going back decades for Tests and ODIs, and complete coverage of every IPL season since the league's inception in 2008. The "recently added" option returns the most recent 30 matches across all formats for quick previews.

#### 🔁 How often is the dataset refreshed?

Cricsheet adds new matches within hours to days of completion. Every run of this Actor pulls live data from the archive, so your dataset reflects the current state at run time.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. Daily refreshes during a tournament keep downstream cricket dashboards in sync.

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

Cricsheet publishes match data under a permissive open-data licence (ODC-BY) that allows free use including commercial purposes, with attribution. Review the Cricsheet terms for your specific use case.

#### 💳 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 gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 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

Cricsheet 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 run notifications in your channels
- [**n8n**](https://docs.apify.com/platform/integrations/n8n) - Self-hosted automation pipelines
- [**Pipedream**](https://docs.apify.com/platform/integrations/pipedream) - Event-driven workflow automation
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe cricket data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**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 cricket data into your product backend, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**⚽ Football Stats Scraper**](https://apify.com/parseforge/football-stats-scraper) - Live and historical football match data
- [**🏀 NBA Stats Scraper**](https://apify.com/parseforge/nba-stats-scraper) - NBA player and team statistics
- [**🎾 ATP Tennis Scraper**](https://apify.com/parseforge/atp-tennis-scraper) - Professional tennis match results
- [**📊 ESPN Stats Scraper**](https://apify.com/parseforge/espn-stats-scraper) - Multi-sport stats and scores
- [**🏟️ Sportradar Scraper**](https://apify.com/parseforge/sportradar-scraper) - Comprehensive sports data feeds

> 💡 **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 Cricsheet, the BCCI, ICC, or any cricket league or governing body. All trademarks mentioned are the property of their respective owners. Only publicly available open cricket data is collected.

# Actor input Schema

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

matches = one row per match (summary + aggregate stats). deliveries = one row per ball with batter, bowler, runs, wicket info — Cricsheet's main value.

## `matchType` (type: `string`):

Cricket format or league. 'Recently added' returns the most recent ~30 matches across all formats.

## `team` (type: `string`):

Only return matches where this team played (case-insensitive, partial allowed). Leave empty for all.

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

Only return matches from this season/year (e.g. 2024, 2023/24). Leave empty for all.

## `gender` (type: `string`):

Limit to men's or women's matches.

## `venue` (type: `string`):

Substring match against venue name (case-insensitive). Example: 'Eden Gardens'. Leave empty for all venues.

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

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

## Actor input object example

```json
{
  "mode": "matches",
  "matchType": "recently_added_30",
  "gender": "",
  "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": "matches",
    "matchType": "recently_added_30",
    "maxItems": 10
};

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/cricsheet-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": "matches",
  "matchType": "recently_added_30",
  "maxItems": 10
}' |
apify call parseforge/cricsheet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cricsheet Cricket Match Data Scraper",
        "description": "Scrape cricket match data from Cricsheet including Test, ODI, T20I, IPL, BBL, PSL, CPL, The Hundred and more. Returns structured match metadata: teams, winner, venue, toss, player-of-match. No API key required.",
        "version": "0.0",
        "x-build-id": "afLcAdQu17o4ByNbf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cricsheet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cricsheet-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~cricsheet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cricsheet-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~cricsheet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cricsheet-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": "Output Mode",
                        "enum": [
                            "matches",
                            "deliveries"
                        ],
                        "type": "string",
                        "description": "matches = one row per match (summary + aggregate stats). deliveries = one row per ball with batter, bowler, runs, wicket info — Cricsheet's main value.",
                        "default": "matches"
                    },
                    "matchType": {
                        "title": "Match Type / League",
                        "enum": [
                            "recently_added_30",
                            "tests",
                            "odis",
                            "t20s",
                            "ipl",
                            "bbl",
                            "psl",
                            "cpl",
                            "the_hundred",
                            "wbbl",
                            "wpl",
                            "sat20",
                            "ilt20",
                            "mdm",
                            "odm",
                            "wc"
                        ],
                        "type": "string",
                        "description": "Cricket format or league. 'Recently added' returns the most recent ~30 matches across all formats.",
                        "default": "recently_added_30"
                    },
                    "team": {
                        "title": "Team Filter",
                        "type": "string",
                        "description": "Only return matches where this team played (case-insensitive, partial allowed). Leave empty for all."
                    },
                    "season": {
                        "title": "Season Filter",
                        "type": "string",
                        "description": "Only return matches from this season/year (e.g. 2024, 2023/24). Leave empty for all."
                    },
                    "gender": {
                        "title": "Gender Filter",
                        "enum": [
                            "",
                            "male",
                            "female"
                        ],
                        "type": "string",
                        "description": "Limit to men's or women's matches.",
                        "default": ""
                    },
                    "venue": {
                        "title": "Venue Filter",
                        "type": "string",
                        "description": "Substring match against venue name (case-insensitive). Example: 'Eden Gardens'. Leave empty for all venues."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
