# Cricket Intelligence API (`fetchfinch/cricket-intelligence-api`) Actor

Structured cricket match, player, series, ranking, news, and historical intelligence for sports apps, dashboards, and research workflows.

- **URL**: https://apify.com/fetchfinch/cricket-intelligence-api.md
- **Developed by:** [Fetch Finch](https://apify.com/fetchfinch) (community)
- **Categories:** Developer tools, Automation, News
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 cricket intelligence results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Cricket Intelligence API

Turn cricket data into production-ready match centres, dashboards, research tools, and sports experiences with one structured Actor.

Cricket Intelligence API gives you a consistent way to discover matches, inspect live scores, explore scorecards, follow players and series, and build historical views from the same JSON response format.

### Why use it

- Build a complete cricket match centre with metadata, live score, scorecard, squads, overs, and optional ball-by-ball commentary.
- Find matches and players by familiar names instead of learning numeric identifiers first.
- Track score progression over time with compact match history snapshots.
- Combine live match discovery with series, player, team, venue, ranking, and news data.
- Use normalized fields for application logic while retaining rich nested detail for analysis.
- Export results as JSON, CSV, Excel, or XML through the standard Apify dataset tools.

### Built for

- Sports websites and mobile apps
- Live score dashboards and newsroom tools
- Fantasy cricket and fan engagement products
- Match previews, reports, and editorial workflows
- Cricket research, analytics, and internal data products

### Quick start

Choose a resource and run the Actor. Most workflows can start with the defaults.

#### Discover current matches

```json
{
  "mode": "sync",
  "resource": "overview"
}
```

#### Get a match by teams and date

You can use friendly search fields without knowing a match ID. The response includes the canonical match ID that was selected.

```json
{
  "mode": "sync",
  "resource": "match",
  "teamName": "India",
  "opponent": "Sri Lanka",
  "matchDate": "2026-08-23",
  "matchParts": ["info", "liveScore", "scorecard"]
}
```

#### Get a player profile by name

```json
{
  "mode": "sync",
  "resource": "player",
  "playerName": "Virat Kohli"
}
```

#### Read a previously collected result

Use cache mode when you want a predictable read of available stored data without requesting a fresh collection.

```json
{
  "mode": "cache",
  "resource": "matchHistory",
  "matchId": 163017,
  "historyLimit": 100
}
```

Direct match, series, player, team, and venue IDs are also supported for deterministic integrations.

### Available resources

| Resource | What you can build |
| --- | --- |
| Overview | Live, upcoming, and recent match discovery |
| Live matches | Scoreboard feeds and match watchlists |
| Match | Match centre data, scorecards, squads, overs, and commentary |
| Match history | Historical score progression snapshots |
| Series | Series metadata, fixtures, and match history |
| Player search | Player discovery and canonical IDs |
| Player | Player profile pages and research cards |
| Team | Team players, schedule, results, and statistics |
| Venue | Venue profiles and location details |
| Rankings | Team and player ranking tables |
| News | Cricket news feeds for briefings and content workflows |

Full commentary is opt-in so ordinary match requests stay compact. Each response includes the selected resource, retrieval time, cache metadata, normalized data, and any friendly lookup resolution.

### Customer example tasks

Try a workflow in one click:

- [Browse Cricket Match Overview](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-overview-cache): live, upcoming, and recent matches.
- [Read Live Cricket Scores](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-live-scoreboard): a ready-made live scoreboard response.
- [Explore a Cricket Match Centre](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-match-centre-search): friendly team and date lookup with scorecard data.
- [Read Match History Snapshots](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-match-history): score progression for a watched match.
- [Explore a Cricket Series](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-series-profile): series lookup by name and category.
- [Get a Player Profile by Name](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-player-profile): name-based profile resolution.
- [Search Cricket Players](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-player-search): discover player IDs for follow-up requests.
- [Read ICC Team Rankings](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-team-rankings): current team rankings.
- [Read a Cricket News Briefing](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-news-briefing): a ready-made news feed response.
- [Fetch Full Match Commentary](https://apify.com/fetchfinch/cricket-intelligence-api/examples/cricket-full-match-commentary): opt-in ball-by-ball commentary.

### Output and integrations

Every run writes one structured result to the default dataset. Use the Apify Console, Dataset API, webhooks, or your preferred integration to consume it in downstream applications.

The top-level result stays consistent across resources:

- `resource` identifies the requested workflow.
- `mode` identifies a fresh or stored read.
- `retrievedAt` records when the result was produced.
- `data` contains the normalized resource-specific payload.
- `data.resolution` explains a friendly name-based match, series, or player lookup.
- `upstream` reports request metadata for operational visibility.

### Pricing

Cricket Intelligence API uses simple pay-per-result pricing. The main result event is **$0.05 per completed dataset result**. Apify displays the complete charge before a run and in the run billing details.

### Data quality notes

Live availability depends on the match state and the information available for that fixture. Full commentary can be substantially larger than a normal scorecard, so request it only when your workflow needs ball-by-ball detail.

If a friendly lookup returns multiple candidates, add an opponent, date, or series name. The Actor reports the candidates instead of silently guessing.

# Actor input Schema

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

Sync may collect fresh data when cache entries expire. Cache reads stored data and may return a stale result.

## `resource` (type: `string`):

The intelligence resource to retrieve.

## `matchId` (type: `integer`):

Optional expert shortcut. If omitted, use Match search, teams, date, or series below.

## `matchQuery` (type: `string`):

Optional text search across team names, match description, and series name. Use this instead of Match ID for friendly lookup.

## `teamName` (type: `string`):

For match lookup, the team playing in the match. Combine with Opponent or Match date when possible.

## `opponent` (type: `string`):

For match lookup, the opposing team name.

## `matchDate` (type: `string`):

Optional match start date in YYYY-MM-DD format.

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

For match or series lookup, a partial or full series name such as India tour of Sri Lanka.

## `matchParts` (type: `array`):

Full commentary is intentionally opt-in because it can be very large.

## `hydrateLive` (type: `boolean`):

For liveMatches, fetch detailed data for up to maxLiveMatches live matches and record their history.

## `maxLiveMatches` (type: `integer`):

Maximum number of live matches to hydrate during a liveMatches sync.

## `hydratedMatchParts` (type: `array`):

Match parts fetched for each hydrated live match. Full commentary is excluded by default.

## `seriesId` (type: `integer`):

Optional expert shortcut. If omitted for Series, use Series name and category below.

## `seriesType` (type: `string`):

Category used when resolving a series name without an ID.

## `playerId` (type: `integer`):

Optional expert shortcut. If omitted for Player profile, enter Player name below.

## `playerName` (type: `string`):

Player name used to resolve a profile without knowing the canonical ID.

## `playerQuery` (type: `string`):

Required for Player search.

## `teamId` (type: `integer`):

Required for the Team profile resource.

## `venueId` (type: `integer`):

Required for the Venue profile resource.

## `historyLimit` (type: `integer`):

Maximum number of most-recent match snapshots to return from the persistent cache.

## `rankingType` (type: `string`):

ICC ranking category to retrieve when resource is Rankings.

## `rankingFormat` (type: `string`):

Match format for ICC rankings. Women rankings support test and t20.

## `rankingWomen` (type: `boolean`):

Return women rankings instead of men rankings.

## `refresh` (type: `boolean`):

Ignore fresh cache entries and collect fresh data in sync mode.

## `maxRequests` (type: `integer`):

Hard per-run quota guard. Use 1–5 for ordinary scheduled runs.

## `includeRawData` (type: `boolean`):

Adds the original unnormalized response to the dataset result. Prefer false for regular runs.

## Actor input object example

```json
{
  "mode": "sync",
  "resource": "overview",
  "matchParts": [
    "info",
    "liveScore",
    "scorecard"
  ],
  "hydrateLive": false,
  "maxLiveMatches": 1,
  "hydratedMatchParts": [
    "info",
    "liveScore",
    "scorecard"
  ],
  "seriesType": "international",
  "historyLimit": 100,
  "rankingType": "teams",
  "rankingFormat": "odi",
  "rankingWomen": false,
  "refresh": false,
  "maxRequests": 5,
  "includeRawData": false
}
```

# Actor output Schema

## `results` (type: `string`):

Open the default dataset to inspect normalized match, player, series, ranking, news, and cache data.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchfinch/cricket-intelligence-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fetchfinch/cricket-intelligence-api").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call fetchfinch/cricket-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetchfinch/cricket-intelligence-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Wa0Tjf8V6WcYyNP8L/builds/A7DlUPfOXFa7frVqh/openapi.json