# Cricbuzz Scraper (`solidcode/cricbuzz-scraper`) Actor

\[💰 $2.5 / 1K] Get live, recent, and upcoming cricket matches, full batting & bowling scorecards, series schedules, player profiles, and news from Cricbuzz. Filter by format and category, or paste any Cricbuzz link. Clean structured data for dashboards, analytics, and fantasy apps.

- **URL**: https://apify.com/solidcode/cricbuzz-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 cricket records

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

## Cricbuzz Scraper

Pull live cricket data from Cricbuzz at scale — live, recent, and upcoming matches, series schedules, ball-accurate batting and bowling scorecards, player profiles with career stats, and cricket news, all in one structured dataset. Built for fantasy-cricket app builders, sports-data analysts, and cricket media and betting teams who need clean, structured live scores and match detail without copy-pasting from Cricbuzz page by page.

### Why This Scraper?

- **Five data types in one actor** — matches, series schedules, full scorecards, player profiles, and news. Competitors stop at match lists; this pulls the whole cricket stack from a single run.
- **Complete batting and bowling scorecards** — every batter's runs, balls, fours, sixes, strike rate, and dismissal, plus every bowler's overs, maidens, runs conceded, wickets, and economy, for all innings of a match (up to 4 for a Test).
- **Three match states, four categories** — live in-progress, recently completed, or upcoming fixtures across International, League (IPL, BBL, and more), Domestic, and Women's cricket.
- **Five format filters** — narrow to T20, ODI, Test, T10, or Other, or leave open to capture every format in one pass.
- **Player profiles with resolved bios and career stats** — full name, country, role, batting and bowling style, birth date and place, teams, ICC rankings, and format-by-format batting and bowling career records.
- **Cricket news feed, six fields per story** — headline, intro, category, lead image, article URL, and a story link for every item in the news feed. Scrape individual article URLs to also pull the full byline and an ISO publish date.
- **Paste any Cricbuzz link** — drop in a scorecard, series, player, or news URL and the right structured record is detected and returned automatically. No URL formatting to learn.
- **One clean dataset, six record types** — a `recordType` field separates matches, series, batting rows, bowling rows, players, and news, so downstream tools can split them without guesswork.

### Use Cases

**Fantasy Sports**
- Build fantasy scoring engines from live per-innings batting and bowling lines
- Rank players by recent strike rate, economy, and wicket-taking form
- Auto-populate contest player pools from upcoming fixture lists
- Track live match state to lock and settle fantasy lineups

**Sports Analytics**
- Model batter and bowler performance across formats and conditions
- Compare career batting and bowling records between players
- Build innings-by-innings datasets for team and venue analysis
- Track series schedules to plan data pulls around fixture calendars

**Media & Journalism**
- Feed live scorecards into match-report and live-blog templates
- Pull cricket news with bylines and publish dates for content aggregation
- Assemble player fact-files from bios, teams, and career stats
- Monitor recent results across International, Domestic, and Women's cricket

**Betting & Odds Research**
- Track live match state and running scores for in-play models
- Backtest against completed-match scorecards and results
- Monitor upcoming fixtures by format and category for market setup
- Analyze player form to inform prop and top-scorer markets

**App & Product Development**
- Power cricket score widgets and mobile apps with fresh match data
- Enrich existing sports databases with structured Cricbuzz records
- Build player-comparison and stats-lookup features
- Schedule recurring pulls to keep a live-scores backend current

### Getting Started

#### Live International Matches

The simplest run — live international games, no configuration needed:

```json
{
    "dataType": "matches",
    "matchStatus": "live",
    "maxResults": 50
}
````

#### Recent Matches With Full Scorecards

Recently completed matches, each enriched with full batting and bowling cards:

```json
{
    "dataType": "matches",
    "matchStatus": "recent",
    "matchCategory": "international",
    "matchFormat": ["t20", "odi"],
    "includeScorecard": true,
    "maxResults": 20
}
```

#### Players, News, and Direct URLs

Paste Cricbuzz links directly — scorecards, player profiles, series, or news articles are auto-detected:

```json
{
    "startUrls": [
        { "url": "https://www.cricbuzz.com/live-cricket-scorecard/152416" },
        { "url": "https://www.cricbuzz.com/profiles/1413/virat-kohli" },
        { "url": "https://www.cricbuzz.com/cricket-news/latest-news" }
    ]
}
```

#### Cricket News Feed

```json
{
    "dataType": "news",
    "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dataType` | select | `Matches (live / recent / upcoming)` | The kind of cricket data to pull: Matches, Series schedule, Scorecards (from match URLs), Player profiles (from player URLs), or News articles. |
| `matchStatus` | select | `Live matches` | For the Matches option: Live matches, Recent (completed), or Upcoming fixtures. |
| `matchCategory` | select | `International` | Which cricket category to cover: International, League (IPL, BBL, etc.), Domestic, or Women's. Applies to Matches and Series schedule. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `matchFormat` | select\[] | `[]` (all) | Only keep matches in these formats: T20, ODI, Test, T10, Other. Leave empty to include every format. |

#### Direct URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | `[]` | Paste Cricbuzz URLs — scorecard, series, player, or news pages. The right data is detected automatically from each link. Required for the Scorecards and Player profiles options. |

#### Enrichment & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeScorecard` | boolean | `false` | With the Matches option, also pull each match's full batting and bowling scorecard. Adds detailed innings rows per match. |
| `maxResults` | integer | `50` | Maximum number of items to return (matches, series, players, or news), up to 5,000 per run. Scorecard rows for a fetched match are always included and do not count against this limit. |

### Output

Every record carries a `recordType` field. Match, series, player, and news records are primary results; batting and bowling rows are per-innings children of a match scorecard.

#### Match (`recordType: "match"`)

```json
{
    "recordType": "match",
    "matchId": "152416",
    "seriesId": "8676",
    "seriesName": "Australia tour of India, 2024",
    "matchDesc": "3rd Test",
    "matchFormat": "TEST",
    "matchCategory": "international",
    "state": "Complete",
    "status": "India won by 6 wickets",
    "team1": "India",
    "team1ShortName": "IND",
    "team2": "Australia",
    "team2ShortName": "AUS",
    "team1Score": "296 & 187-4 (48.3 ov)",
    "team2Score": "263 & 218 (85.1 ov)",
    "venue": "M. Chinnaswamy Stadium, Bengaluru",
    "startDate": "2024-03-01T04:00:00+00:00",
    "endDate": "2024-03-05T11:30:00+00:00",
    "tossResult": "Australia won the toss and chose to bat",
    "result": "India won by 6 wickets",
    "matchUrl": "https://www.cricbuzz.com/live-cricket-scorecard/152416",
    "scrapedAt": "2026-07-04T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"match"` |
| `matchId` | string | Cricbuzz match identifier |
| `seriesId` / `seriesName` | string | Parent series id and name |
| `matchDesc` | string | Match label, e.g. "3rd Test", "Final" |
| `matchFormat` | string | T20, ODI, TEST, T10, or OTHER |
| `matchCategory` | string | international, league, domestic, or women |
| `state` | string | Preview, In Progress, Complete, Abandoned |
| `status` | string | Human-readable status or result line |
| `team1` / `team2` | string | Team names |
| `team1ShortName` / `team2ShortName` | string | Team short codes |
| `team1Score` / `team2Score` | string | Innings score summary (null if not started) |
| `venue` | string | Ground and city |
| `startDate` / `endDate` | string | ISO 8601 timestamps (nullable) |
| `tossResult` | string | Toss outcome text (nullable) |
| `result` | string | Winner or result text (nullable) |
| `matchUrl` | string | Canonical match URL |
| `scrapedAt` | string | ISO timestamp of extraction |

#### Batting Row (`recordType: "inningsBatting"`)

Child rows of a scorecard — one per batter, per innings.

```json
{
    "recordType": "inningsBatting",
    "matchId": "152416",
    "inningsNumber": 1,
    "battingTeam": "India",
    "batsmanName": "Rohit Sharma",
    "runs": 52,
    "balls": 44,
    "fours": 6,
    "sixes": 2,
    "strikeRate": 118.18,
    "dismissal": "c Smith b Cummins"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"inningsBatting"` |
| `matchId` | string | Parent match id |
| `inningsNumber` | number | Innings number (1–4) |
| `battingTeam` | string | Team batting this innings |
| `batsmanName` | string | Batter name |
| `runs` / `balls` / `fours` / `sixes` | number | Batting line |
| `strikeRate` | number | Strike rate |
| `dismissal` | string | How out (null when not out) |

#### Bowling Row (`recordType: "inningsBowling"`)

Child rows of a scorecard — one per bowler, per innings.

```json
{
    "recordType": "inningsBowling",
    "matchId": "152416",
    "inningsNumber": 1,
    "bowlingTeam": "Australia",
    "bowlerName": "Pat Cummins",
    "overs": 18.2,
    "maidens": 4,
    "runsConceded": 61,
    "wickets": 3,
    "economy": 3.32
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"inningsBowling"` |
| `matchId` | string | Parent match id |
| `inningsNumber` | number | Innings number (1–4) |
| `bowlingTeam` | string | Team bowling this innings |
| `bowlerName` | string | Bowler name |
| `overs` | number | Overs bowled |
| `maidens` / `runsConceded` / `wickets` | number | Bowling line |
| `economy` | number | Economy rate |

#### Series (`recordType: "series"`)

```json
{
    "recordType": "series",
    "seriesId": "8676",
    "seriesName": "Australia tour of India, 2024",
    "matchCategory": "international",
    "startDate": "2024-02-09T04:00:00+00:00",
    "endDate": "2024-03-05T11:30:00+00:00",
    "matchCount": 5,
    "seriesUrl": "https://www.cricbuzz.com/cricket-series/8676",
    "scrapedAt": "2026-07-04T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"series"` |
| `seriesId` / `seriesName` | string | Series id and name |
| `matchCategory` | string | international, league, domestic, or women |
| `startDate` / `endDate` | string | ISO 8601 span of the series (nullable) |
| `matchCount` | number | Number of matches in the series (nullable) |
| `seriesUrl` | string | Canonical series URL |
| `scrapedAt` | string | ISO timestamp of extraction |

#### Player (`recordType: "player"`)

```json
{
    "recordType": "player",
    "playerId": "1413",
    "name": "Virat Kohli",
    "fullName": "Virat Kohli",
    "country": "India",
    "role": "Batsman",
    "battingStyle": "Right-hand bat",
    "bowlingStyle": "Right-arm medium",
    "birthDate": "Nov 05, 1988",
    "birthPlace": "Delhi",
    "teams": ["India", "Royal Challengers Bengaluru", "India U19"],
    "bio": "Virat Kohli is a modern-day great whose consistency across formats...",
    "rankings": { "bat": { "testBestRank": "1", "odiBestRank": "1" } },
    "battingStats": { "Test": { "matches": "113", "runs": "8848", "avg": "49.15" } },
    "bowlingStats": { "Test": { "wickets": "0" } },
    "profileUrl": "https://www.cricbuzz.com/profiles/1413/virat-kohli",
    "scrapedAt": "2026-07-04T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"player"` |
| `playerId` | string | Cricbuzz player id |
| `name` / `fullName` | string | Display name and full name |
| `country` | string | Country / international team |
| `role` | string | Batsman, Bowler, All-rounder, or WK-Batsman |
| `battingStyle` / `bowlingStyle` | string | Style descriptors (nullable) |
| `birthDate` / `birthPlace` | string | Date and place of birth (nullable) |
| `teams` | string\[] | Teams the player has represented |
| `bio` | string | Full profile bio text (nullable) |
| `rankings` | object | Current ICC rankings by format (nullable) |
| `battingStats` / `bowlingStats` | object | Career records by format |
| `profileUrl` | string | Canonical profile URL |
| `scrapedAt` | string | ISO timestamp of extraction |

#### News (`recordType: "news"`)

Example of a row from the news feed (`dataType: "news"`). On the feed, `author` is empty and `publishedAt` is a relative time. Scrape an individual article URL and both fill in with the full byline and an ISO date.

```json
{
    "recordType": "news",
    "newsId": "128745",
    "title": "India seal series with clinical Test win",
    "intro": "A composed fourth-innings chase gave India the series 3-1...",
    "category": "News",
    "author": null,
    "publishedAt": "1d ago",
    "imageUrl": "https://static.cricbuzz.com/a/img/v1/i1/c128745/i.jpg",
    "newsUrl": "https://www.cricbuzz.com/cricket-news/128745",
    "scrapedAt": "2026-07-04T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"news"` |
| `newsId` | string | Article id |
| `title` | string | Headline |
| `intro` | string | Summary / standfirst (nullable) |
| `category` | string | News category (nullable) |
| `author` | string | Byline. Populated when you scrape an individual article URL; empty on the news feed |
| `publishedAt` | string | Publish date. ISO 8601 when you scrape an individual article URL; a relative time (e.g. "1d ago") on the news feed |
| `imageUrl` | string | Lead image URL (nullable) |
| `newsUrl` | string | Article URL |
| `scrapedAt` | string | ISO timestamp of extraction |

### Tips for Best Results

- **Start small, then scale** — set `maxResults` to 10–20 on your first run to confirm the data matches your needs before pulling hundreds of items.
- **Enable scorecards only for the matches you need** — each match with `includeScorecard` on adds roughly 35–50 detailed batting and bowling rows (a full Test can exceed that). Leave it off for fast, lightweight match lists.
- **Use Recent for settled results** — pick `matchStatus: "recent"` when you want final scores and complete scorecards; Live matches are still in progress and their cards fill in over time.
- **Combine format filters** — pass multiple formats (e.g. `["t20", "odi"]`) to capture several limited-overs formats in a single run while excluding Tests.
- **Paste URLs for pinpoint pulls** — for a specific scorecard or player, drop the Cricbuzz URL into Direct URLs rather than scanning a full list; it is faster and exact.
- **Split records by `recordType` downstream** — filter on `recordType` to route matches, scorecards, players, and news into separate tables or sheets.
- **Match categories mirror Cricbuzz's own tabs** — International, League, Domestic, and Women's map directly to the site's sections, so you get the same coverage you would browsing by hand.

### Pricing

**From $2.50 per 1,000 results** — the primary rate for each match, series, player, or news record, undercutting comparable cricket data actors. Scorecard rows are billed separately and only when you switch them on.

This actor uses pay-per-result pricing with two event types. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Apify loyalty-tier discounts (Bronze, Silver, Gold) apply automatically as you scale.

| Event | No discount | Bronze | Silver | Gold |
|-------|-------------|--------|--------|------|
| Record (match / series / player / news) — per 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| Scorecard row (batting / bowling line) — per 1,000 | $0.48 | $0.45 | $0.42 | $0.40 |

Scorecard rows are only produced when **Include full scorecards** is enabled (off by default), so a plain match, series, player, or news run is billed purely at the Record rate.

#### What You'd Pay (Gold tier)

| Run | Records | Scorecard rows | Cost |
|-----|---------|----------------|------|
| 1,000 matches, no scorecards | 1,000 | 0 | $2.50 |
| 100 matches with scorecards | 100 | ~3,500 | ~$1.65 |
| 10,000 news articles | 10,000 | 0 | $25.00 |

A small fixed start fee ($0.005 per GB per run) applies once per run. Platform fees for storage and data transfer depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate cricket research, analytics, media, and app development. Users are responsible for complying with applicable laws and Cricbuzz's Terms of Service. Extract only publicly available data, respect rate limits, and do not use collected data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `dataType` (type: `string`):

Pick the kind of cricket data you want. 'Matches' returns live, recent, or upcoming games. 'Series schedule' lists tournaments. 'Scorecards' pulls full batting & bowling cards from match URLs. 'Player profiles' returns player bios and career stats. 'News' returns cricket articles.

## `matchStatus` (type: `string`):

Only used when scraping Matches. Choose live matches in progress, recently completed matches, or upcoming fixtures.

## `matchCategory` (type: `string`):

Which cricket category to cover. Applies to Matches and Series schedule.

## `matchFormat` (type: `array`):

Only keep matches in these formats. Leave empty to include all formats.

## `startUrls` (type: `array`):

Paste Cricbuzz URLs to scrape directly — match/scorecard pages, series pages, player profiles, or news articles. The right data is detected automatically from each URL. Required for the Scorecards and Player profiles options.

## `includeScorecard` (type: `boolean`):

When scraping Matches, also fetch each match's full batting & bowling scorecard. This adds detailed innings rows for every match and increases the number of results.

## `maxResults` (type: `integer`):

Maximum number of items to return (matches, series, players, or news articles), up to 5,000 per run. Full scorecard rows for a fetched match are always included and do not count against this limit.

## Actor input object example

```json
{
  "dataType": "matches",
  "matchStatus": "live",
  "matchCategory": "international",
  "matchFormat": [],
  "startUrls": [],
  "includeScorecard": false,
  "maxResults": 50
}
```

# Actor output Schema

## `matches` (type: `string`):

Live, recent, and upcoming matches.

## `series` (type: `string`):

Series and tournament schedule.

## `batting` (type: `string`):

Per-innings batting rows from match scorecards.

## `bowling` (type: `string`):

Per-innings bowling rows from match scorecards.

## `players` (type: `string`):

Player profiles and career stats.

## `news` (type: `string`):

Cricket news articles.

# 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 = {
    "dataType": "matches",
    "matchStatus": "live",
    "matchCategory": "international",
    "matchFormat": [],
    "startUrls": [],
    "includeScorecard": false,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/cricbuzz-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 = {
    "dataType": "matches",
    "matchStatus": "live",
    "matchCategory": "international",
    "matchFormat": [],
    "startUrls": [],
    "includeScorecard": False,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/cricbuzz-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 '{
  "dataType": "matches",
  "matchStatus": "live",
  "matchCategory": "international",
  "matchFormat": [],
  "startUrls": [],
  "includeScorecard": false,
  "maxResults": 50
}' |
apify call solidcode/cricbuzz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cricbuzz Scraper",
        "description": "[💰 $2.5 / 1K] Get live, recent, and upcoming cricket matches, full batting & bowling scorecards, series schedules, player profiles, and news from Cricbuzz. Filter by format and category, or paste any Cricbuzz link. Clean structured data for dashboards, analytics, and fantasy apps.",
        "version": "1.0",
        "x-build-id": "6LynxaeQYvz3HU1Lb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~cricbuzz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-cricbuzz-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/solidcode~cricbuzz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-cricbuzz-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/solidcode~cricbuzz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-cricbuzz-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": {
                    "dataType": {
                        "title": "What to scrape",
                        "enum": [
                            "matches",
                            "series",
                            "scorecard",
                            "player",
                            "news"
                        ],
                        "type": "string",
                        "description": "Pick the kind of cricket data you want. 'Matches' returns live, recent, or upcoming games. 'Series schedule' lists tournaments. 'Scorecards' pulls full batting & bowling cards from match URLs. 'Player profiles' returns player bios and career stats. 'News' returns cricket articles.",
                        "default": "matches"
                    },
                    "matchStatus": {
                        "title": "Match status",
                        "enum": [
                            "live",
                            "recent",
                            "upcoming"
                        ],
                        "type": "string",
                        "description": "Only used when scraping Matches. Choose live matches in progress, recently completed matches, or upcoming fixtures.",
                        "default": "live"
                    },
                    "matchCategory": {
                        "title": "Category",
                        "enum": [
                            "international",
                            "league",
                            "domestic",
                            "women"
                        ],
                        "type": "string",
                        "description": "Which cricket category to cover. Applies to Matches and Series schedule.",
                        "default": "international"
                    },
                    "matchFormat": {
                        "title": "Match formats",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep matches in these formats. Leave empty to include all formats.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "t20",
                                "odi",
                                "test",
                                "t10",
                                "other"
                            ],
                            "enumTitles": [
                                "T20",
                                "ODI",
                                "Test",
                                "T10",
                                "Other"
                            ]
                        }
                    },
                    "startUrls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Paste Cricbuzz URLs to scrape directly — match/scorecard pages, series pages, player profiles, or news articles. The right data is detected automatically from each URL. Required for the Scorecards and Player profiles options.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeScorecard": {
                        "title": "Include full scorecards",
                        "type": "boolean",
                        "description": "When scraping Matches, also fetch each match's full batting & bowling scorecard. This adds detailed innings rows for every match and increases the number of results.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of items to return (matches, series, players, or news articles), up to 5,000 per run. Full scorecard rows for a fetched match are always included and do not count against this limit.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
