# Cricbuzz Live Match Scores Scraper (`automation-lab/cricbuzz-live-match-scores-scraper`) Actor

Extract live, recent, and upcoming Cricbuzz matches with teams, innings scores, venues, status, timestamps, winners, and canonical score links.

- **URL**: https://apify.com/automation-lab/cricbuzz-live-match-scores-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Automation, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Live Match Scores Scraper

Turn the public Cricbuzz live-scores page into a clean cricket match dataset.

Extract current, recent, and upcoming matches with teams, innings scores, venues, timestamps, status, winners, and canonical Cricbuzz links—without maintaining a browser crawler.

Use the Actor once for an export or run it on an Apify schedule to power a recurring cricket-data feed.

### What does Cricbuzz Live Match Scores Scraper do?

The Actor reads the public Cricbuzz live match feed and saves one normalized dataset row per match.

Each row can contain:

- 🏏 match and series IDs
- 🏆 series name, match description, format, and type
- ⏱️ start time, end time, state, and detailed status
- 👥 both teams, IDs, abbreviations, and innings scores
- 📍 venue ground, city, and timezone
- ✅ winner and short status when Cricbuzz provides enough information
- 🔗 live-score, scorecard, and commentary links
- 🕒 the UTC extraction timestamp

The default input is intentionally small and ready to run.

### Who is this cricket score scraper for?

#### Fantasy-cricket product teams

Poll active matches and feed normalized scores into contest operations, alerts, or internal dashboards.

#### Sports app developers

Replace brittle page selectors with a stable JSON dataset or API response.

#### Newsrooms and cricket media teams

Monitor match states, final results, and canonical links for editorial workflows.

#### Cricket analysts

Archive snapshots during a tour or competition for later comparison and modeling.

#### Data pipeline engineers

Schedule a filtered feed and deliver it to a webhook, database, spreadsheet, or cloud warehouse.

### Why use this Actor?

- **HTTP-first:** no browser startup overhead for the proven live feed.
- **Structured output:** nested teams, innings, and venue objects preserve useful context.
- **Useful filters:** select formats, states, teams, or a series-name phrase before export.
- **Repeatable:** run manually, through an API, or on an Apify schedule.
- **Fail-loud reliability:** a missing Cricbuzz match payload fails the run instead of silently returning a misleading success.
- **Export-ready:** download JSON, CSV, Excel, XML, RSS, or JSONL from Apify.

### What Cricbuzz data can I extract?

| Field | Description |
|---|---|
| `matchId` | Cricbuzz match identifier |
| `seriesId` | Cricbuzz series identifier |
| `seriesName` | Tour, league, or competition name |
| `description` | Match label such as `3rd ODI` |
| `format` | Test, ODI, T20, T10, or another source format |
| `matchType` | International or other source classification |
| `state` | Source match state |
| `status` | Detailed score or result status |
| `shortStatus` | Compact source status when available |
| `startTime` | ISO 8601 match start time |
| `endTime` | ISO 8601 match end time when available |
| `team1`, `team2` | IDs, names, abbreviations, and innings arrays |
| `winner` | Inferred winning team for completed results |
| `venue` | Venue ID, ground, city, and timezone |
| `liveScoreUrl` | Canonical Cricbuzz live score page |
| `scorecardUrl` | Canonical Cricbuzz scorecard page |
| `commentaryUrl` | Canonical Cricbuzz commentary page |
| `scrapedAt` | UTC timestamp for the snapshot |

### How to scrape Cricbuzz live scores

1. Open the Actor input page.
2. Choose a low `maxItems` value for your first run.
3. Optionally choose match formats or states.
4. Optionally enter team names or a series phrase.
5. Click **Start**.
6. Review the dataset table.
7. Export the results or connect the Actor to your workflow.

A broad first run needs only:

```json
{
  "maxItems": 20
}
````

### Input options

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `maxItems` | integer | 50 | Stop after this many filtered matches |
| `matchFormats` | string array | all | Keep selected cricket formats |
| `matchStates` | string array | all | Keep live, upcoming, complete, or abandoned matches |
| `teams` | string array | all | Match either team's name or abbreviation |
| `seriesQuery` | string | empty | Require a phrase in the series name |

`maxItems` is applied after all filters.

Team matching is case-insensitive and accepts abbreviations such as `IND`, `ENG`, or `WI`.

### Filter examples

#### Live T20 matches

```json
{
  "matchFormats": ["T20"],
  "matchStates": ["LIVE"],
  "maxItems": 100
}
```

#### India and England matches

```json
{
  "teams": ["India", "England"],
  "maxItems": 50
}
```

#### One tour or competition

```json
{
  "seriesQuery": "World Cup",
  "maxItems": 100
}
```

Filters describe the current public live-scores feed; they do not search Cricbuzz's full historical archive.

### Output example

```json
{
  "matchId": 129480,
  "seriesId": 10532,
  "seriesName": "India tour of England, 2026",
  "description": "3rd ODI",
  "format": "ODI",
  "state": "Complete",
  "status": "England won by 27 runs",
  "team1": {
    "id": 9,
    "name": "England",
    "shortName": "ENG",
    "innings": [{ "inningsId": 1, "runs": 315, "wickets": 8, "overs": 50 }]
  },
  "team2": {
    "id": 2,
    "name": "India",
    "shortName": "IND",
    "innings": [{ "inningsId": 2, "runs": 288, "wickets": 10, "overs": 48.2 }]
  },
  "winner": "England",
  "venue": {
    "ground": "Lord's",
    "city": "London",
    "timezone": "+01:00"
  },
  "liveScoreUrl": "https://www.cricbuzz.com/live-cricket-scores/129480/england-vs-india-3rd-odi",
  "scorecardUrl": "https://www.cricbuzz.com/live-cricket-scorecard/129480/england-vs-india-3rd-odi",
  "commentaryUrl": "https://www.cricbuzz.com/live-cricket-full-commentary/129480/england-vs-india-3rd-odi",
  "scrapedAt": "2026-07-20T02:00:00.000Z"
}
```

Values change with Cricbuzz's current feed. Some upcoming matches do not yet have innings or an end time.

### How much does it cost to scrape Cricbuzz matches?

The Actor uses pay-per-event pricing:

- a small one-time **Start** charge per run
- one **Match record** charge for each saved dataset row
- automatic tier discounts based on your Apify plan

The current base configuration is a $0.005 start and $0.000091804 per match on the Bronze tier, with lower per-record prices on higher tiers.

Because one HTTP request can provide many records, scheduled feed snapshots remain inexpensive. Check the Actor's Pricing tab for your exact plan price.

### Scheduling a live cricket monitor

For a live dashboard:

1. Save an Actor task with your team, format, or series filters.
2. Create an Apify schedule during match windows.
3. Keep `maxItems` aligned with the expected feed size.
4. Send each finished run to a webhook or integration.
5. Deduplicate snapshots downstream with `matchId` and `scrapedAt`.

A five-minute schedule is usually more useful during active play than an always-on process.

### Integrations

#### Webhooks

Send a run-finished webhook to your API, automation platform, or queue.

#### Google Sheets

Export current matches for newsroom or operations teams that prefer a spreadsheet.

#### Make and Zapier

Trigger alerts when a filtered dataset contains a live match or completed result.

#### Databases and warehouses

Load JSONL into PostgreSQL, BigQuery, Snowflake, or another analytics store.

#### Slack and Discord

Format newly completed match rows into result notifications.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cricbuzz-live-match-scores-scraper').call({
  matchFormats: ['T20'],
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cricbuzz-live-match-scores-scraper').call(
    run_input={'teams': ['India'], 'maxItems': 50}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cricbuzz-live-match-scores-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"matchStates":["LIVE"],"maxItems":20}'
```

Use the returned run ID to inspect status and retrieve the default dataset.

### Use with Apify MCP

Connect the Actor to AI clients through Apify's MCP server:

```text
https://mcp.apify.com?tools=automation-lab/cricbuzz-live-match-scores-scraper
```

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/cricbuzz-live-match-scores-scraper"
```

#### Claude Desktop setup

Add this remote MCP server configuration through a compatible HTTP connector:

```json
{
  "mcpServers": {
    "apify-cricbuzz": {
      "url": "https://mcp.apify.com?tools=automation-lab/cricbuzz-live-match-scores-scraper"
    }
  }
}
```

#### Cursor setup

Use the same `mcpServers` JSON in Cursor's MCP settings and authenticate with your Apify credentials when prompted.

#### VS Code setup

Add the remote HTTP endpoint in your VS Code MCP extension settings, then enable the `automation-lab/cricbuzz-live-match-scores-scraper` tool.

Example prompts:

- “Run the Cricbuzz scraper and show current live T20 matches.”
- “Find matches involving India and summarize the innings scores.”
- “Export completed match results from the current Cricbuzz feed.”

### Data freshness

Every run fetches the current public Cricbuzz live-scores page.

`startTime` and `endTime` describe the match. `scrapedAt` describes when this Actor observed the record.

For live use cases, schedule repeated runs and retain snapshots. For one-time final scores, run after matches complete.

### Reliability and error handling

The Actor performs bounded retries for transient HTTP failures.

It checks for Cricbuzz's structured match payload before parsing.

If Cricbuzz returns an unrecognized page, the run fails non-zero rather than pretending an empty scrape succeeded.

Duplicate source records are removed by `matchId`.

A valid filter can legitimately return zero items when no current match meets it.

### Limitations

- Version 1 covers the public live/recent match feed only.
- It does not crawl historical score archives.
- It does not fetch ball-by-ball commentary text or player profiles.
- Canonical scorecard and commentary URLs are included, but their detail pages are not scraped.
- Source availability and field completeness depend on Cricbuzz.
- Very narrow filters may yield no current records.

### Tips for stable workflows

- Start with an unfiltered run to understand the current feed.
- Use Cricbuzz abbreviations when team names vary.
- Store `matchId` as your stable match key.
- Store `scrapedAt` when keeping live snapshots.
- Treat missing innings as normal for upcoming matches.
- Avoid polling faster than your product actually needs.

### Is scraping Cricbuzz legal?

This Actor extracts publicly visible match information without authentication.

You are responsible for complying with Cricbuzz's terms, applicable database and copyright rules, privacy laws, and your intended use.

Do not use the Actor to overload the website, bypass access controls, or republish protected editorial content without permission.

Match facts may be usable in many jurisdictions, but legal requirements depend on your location and product. Seek legal advice for high-risk commercial use.

### Troubleshooting

#### Why is my dataset empty?

Remove filters and rerun with a small `maxItems`. If records appear, one of your team, state, format, or series filters simply does not match the current feed.

#### Why does the run fail with an unrecognized payload error?

Cricbuzz may have changed the page or served a temporary error. Retry once later and inspect the run log. Persistent failures should be reported through the Actor issue form.

#### Why does an upcoming match have no innings?

No score exists before play begins. The team objects remain present with empty `innings` arrays.

#### Why is the winner missing?

The winner is included when the detailed status starts with a recognizable team name or abbreviation. Draws, no-results, abandoned matches, and unusual status text may not identify a winner.

### Frequently asked questions

#### Does this require a Cricbuzz account or API key?

No. Version 1 reads the anonymous public live-scores page.

#### Does it need a proxy?

No proxy is required for the proven route. The Actor uses conservative HTTP access.

#### Can it scrape one team?

Yes. Add a full team name or abbreviation to `teams`.

#### Can it return only live matches?

Yes. Set `matchStates` to `["LIVE"]`.

#### Can I get CSV or Excel?

Yes. Open the dataset and choose your preferred Apify export format.

#### Can it run on a schedule?

Yes. Save a task and attach an Apify schedule.

#### Does it scrape commentary text?

No. It returns the canonical commentary link but keeps v1 focused on match feed records.

### Related sports and data scrapers

Explore other Automation Lab Actors for adjacent workflows:

- [ESPN News Scraper](https://apify.com/automation-lab/espn-news-scraper) for sports news feeds
- [Fantasy Premier League Data Scraper](https://apify.com/automation-lab/fantasy-premier-league-data-scraper) for football fantasy data
- [Bovada Sportsbook Odds Scraper](https://apify.com/automation-lab/bovada-sportsbook-odds-scraper) for structured sports odds

Combine match status data with news or notification workflows only when you have the right to use each source.

### Support

If a run fails unexpectedly, open an issue from the Actor page.

Include:

- the run URL
- the exact input
- the expected match or filter behavior
- whether an unfiltered run succeeds

Do not include your Apify token or other credentials.

# Actor input Schema

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

Maximum number of matching Cricbuzz match records to save (1–500).

## `matchFormats` (type: `array`):

Keep only selected cricket formats. Leave empty to include every format.

## `matchStates` (type: `array`):

Keep live, upcoming, completed, or abandoned matches. Leave empty for all states.

## `teams` (type: `array`):

Case-insensitive team names or abbreviations, for example India, ENG, or West Indies. A match is kept when either team matches any value.

## `seriesQuery` (type: `string`):

Case-insensitive text that must occur in the Cricbuzz series name, for example World Cup or India tour.

## Actor input object example

```json
{
  "maxItems": 20,
  "matchFormats": [],
  "matchStates": [],
  "teams": []
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 20,
    "matchFormats": [],
    "matchStates": [],
    "teams": [],
    "seriesQuery": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cricbuzz-live-match-scores-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 20,
    "matchFormats": [],
    "matchStates": [],
    "teams": [],
    "seriesQuery": "",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cricbuzz-live-match-scores-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "matchFormats": [],
  "matchStates": [],
  "teams": [],
  "seriesQuery": ""
}' |
apify call automation-lab/cricbuzz-live-match-scores-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cricbuzz Live Match Scores Scraper",
        "description": "Extract live, recent, and upcoming Cricbuzz matches with teams, innings scores, venues, status, timestamps, winners, and canonical score links.",
        "version": "0.1",
        "x-build-id": "3cwxKqgJsGXzQtX20"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cricbuzz-live-match-scores-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cricbuzz-live-match-scores-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/automation-lab~cricbuzz-live-match-scores-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cricbuzz-live-match-scores-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/automation-lab~cricbuzz-live-match-scores-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cricbuzz-live-match-scores-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "🏏 Maximum matches",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of matching Cricbuzz match records to save (1–500).",
                        "default": 50
                    },
                    "matchFormats": {
                        "title": "Match formats",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only selected cricket formats. Leave empty to include every format.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "TEST",
                                "ODI",
                                "T20",
                                "T10",
                                "FIRST_CLASS",
                                "LIST_A",
                                "OTHER"
                            ],
                            "enumTitles": [
                                "Test",
                                "ODI",
                                "T20",
                                "T10",
                                "First class",
                                "List A",
                                "Other"
                            ]
                        }
                    },
                    "matchStates": {
                        "title": "Match states",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep live, upcoming, completed, or abandoned matches. Leave empty for all states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "LIVE",
                                "UPCOMING",
                                "COMPLETE",
                                "ABANDONED"
                            ],
                            "enumTitles": [
                                "Live",
                                "Upcoming",
                                "Complete",
                                "Abandoned"
                            ]
                        }
                    },
                    "teams": {
                        "title": "Teams",
                        "type": "array",
                        "description": "Case-insensitive team names or abbreviations, for example India, ENG, or West Indies. A match is kept when either team matches any value.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "seriesQuery": {
                        "title": "Series name contains",
                        "type": "string",
                        "description": "Case-insensitive text that must occur in the Cricbuzz series name, for example World Cup or India tour."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
