# Flashscore Scraper | Live Sports Scores and Fixtures (`parseforge/flashscore-scraper`) Actor

Pull live scores, fixtures, results, and standings from Flashscore across soccer, tennis, basketball, hockey, baseball, and more. Get match details, lineups, head to head, and statistics for sports analytics, fantasy tools, betting models, and live data dashboards globally.

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

## Pricing

from $19.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚽ Flashscore Scraper

> 🚀 **Export live scores and match results from Flashscore in seconds.** Get home/away teams, scores, match status, tournament, and direct match links for football, tennis, basketball, hockey, and baseball.

> 🕒 **Last updated:** 2026-05-22 · **📊 10 fields** per record · **Multi-sport** · **Global coverage**

Flashscore is one of the world's most popular live sports scores platforms, tracking hundreds of thousands of matches per year across 30+ sports and 90+ countries. This actor scrapes match results directly from the Flashscore website and delivers clean, structured JSON/CSV/Excel datasets ready for analysis, dashboards, and automation.

With this scraper you can export football, tennis, basketball, hockey, and baseball match results for any date - including today's live scores, yesterday's results, and upcoming fixtures.

---

### 🌍 Coverage

- **Sports:** Football, Tennis, Basketball, Hockey, Baseball
- **Date range:** Any past or future date
- **Tournaments:** International (Champions League, Copa Libertadores, etc.), national leagues (Bundesliga, Premier League, Eredivisie, etc.), and cups
- **Fields:** 10 per record including teams, scores, status, tournament, match URL, and timestamp

---

### 🎯 Target Audience / Use Cases

| Who | Why |
|-----|-----|
| Sports analysts | Track results, form, and tournament outcomes |
| Betting researchers | Build historical results databases for modeling |
| Sports journalists | Quickly pull match data for articles |
| App developers | Power live score feeds and sports dashboards |
| Data scientists | Train ML models on historical match outcomes |
| Fantasy sports managers | Track player and team performance |

---

### 📋 What the Flashscore Scraper does

- Scrapes match results for a given sport and date from Flashscore.com
- Returns home/away teams, scores, match status (Finished, Live, Postponed, etc.)
- Includes tournament/league name and country
- Provides direct Flashscore match URL for each game
- Supports football, tennis, basketball, hockey, and baseball
- Respects free/paid tiers with automatic item limiting

---

> 💡 **Why it matters:** Flashscore aggregates real-time and historical match data from hundreds of sports competitions worldwide. This scraper gives you programmatic access to that data without needing to parse complex live websocket streams.

---

### 🎬 Full Demo

🚧 Coming soon

---

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `sport` | select | `football` | Sport to scrape (football, tennis, basketball, hockey, baseball) |
| `date` | string | today | Date in YYYY-MM-DD format |
| `maxItems` | integer | 10 | Maximum number of matches to return |

**Example - Football results from a specific date:**
```json
{
  "sport": "football",
  "date": "2026-05-21",
  "maxItems": 50
}
````

**Example - Today's basketball scores:**

```json
{
  "sport": "basketball",
  "maxItems": 20
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 items per run. Upgrade to a paid plan to unlock up to 1,000,000 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

***

### 📊 Output

Each record contains 10 fields:

| Field | Type | Description |
|-------|------|-------------|
| 🏠 `homeTeam` | string | Home team name |
| 🏃 `awayTeam` | string | Away team name |
| ⚽ `homeScore` | string | Home team score (null if not started) |
| 🥅 `awayScore` | string | Away team score (null if not started) |
| 🔴 `status` | string | Match status (Finished, Live, Postponed, etc.) |
| 📅 `matchDate` | string | Match date (YYYY-MM-DD) |
| 🏆 `tournament` | string | Country and tournament name |
| 🎽 `sport` | string | Sport type |
| 🔗 `matchUrl` | string | Direct Flashscore match URL |
| 🕒 `scrapedAt` | string | ISO timestamp when data was scraped |

**Sample output (5 records from 2026-05-21 football scrape):**

```json
[
  {
    "homeTeam": "Wolfsburg",
    "awayTeam": "Paderborn",
    "homeScore": "0",
    "awayScore": "0",
    "status": "Finished",
    "matchDate": "2026-05-21",
    "tournament": "GERMANY: Bundesliga - Relegation",
    "sport": "football",
    "matchUrl": "https://www.flashscore.com/match/football/paderborn-G2Op923t/wolfsburg-nwkTahLL/?mid=K8bh3OkJ",
    "scrapedAt": "2026-05-22T03:46:36.278Z"
  },
  {
    "homeTeam": "Ajax",
    "awayTeam": "Groningen",
    "homeScore": "2",
    "awayScore": "0",
    "status": "Finished",
    "matchDate": "2026-05-21",
    "tournament": "NETHERLANDS: Eredivisie - Conference League - Play Offs",
    "sport": "football",
    "matchUrl": "https://www.flashscore.com/match/football/ajax-8UOvIwnb/groningen-MBUGcjb9/?mid=AcuhRUx2",
    "scrapedAt": "2026-05-22T03:46:36.278Z"
  },
  {
    "homeTeam": "Utrecht",
    "awayTeam": "Heerenveen",
    "homeScore": "3",
    "awayScore": "2",
    "status": "Finished",
    "matchDate": "2026-05-21",
    "tournament": "NETHERLANDS: Eredivisie - Conference League - Play Offs",
    "sport": "football",
    "matchUrl": "https://www.flashscore.com/match/football/heerenveen-EDjXSyWG/utrecht-p6QXMgOj/?mid=GfSwkYU8",
    "scrapedAt": "2026-05-22T03:46:36.278Z"
  },
  {
    "homeTeam": "La Guaira (Ven)",
    "awayTeam": "Ind. Rivadavia (Arg)",
    "homeScore": "2",
    "awayScore": "4",
    "status": "Finished",
    "matchDate": "2026-05-21",
    "tournament": "SOUTH AMERICA: Copa Libertadores - Group Stage",
    "sport": "football",
    "matchUrl": "https://www.flashscore.com/match/football/deportivo-la-guaira-4SRaHjat/ind-rivadavia-Eg51aDC4/?mid=xG3NcKdd",
    "scrapedAt": "2026-05-22T03:46:36.278Z"
  },
  {
    "homeTeam": "Penarol (Uru)",
    "awayTeam": "Corinthians (Bra)",
    "homeScore": "1",
    "awayScore": "1",
    "status": "Finished",
    "matchDate": "2026-05-21",
    "tournament": "SOUTH AMERICA: Copa Libertadores - Group Stage",
    "sport": "football",
    "matchUrl": "https://www.flashscore.com/match/football/corinthians-QBGfQbSe/penarol-r1hkKQek/?mid=KC8HhsYr",
    "scrapedAt": "2026-05-22T03:46:36.278Z"
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| ⚽ Multi-sport | Football, tennis, basketball, hockey, baseball |
| 📅 Date-flexible | Any past or future date |
| 🏆 Tournament labels | Country and league name included |
| 🔗 Direct match URLs | Link straight to each match page |
| 🚀 Fast | Completes in under 60 seconds for a day's results |
| 💾 Export-ready | JSON, CSV, Excel, XML out of the box |
| 🛡️ Anti-bot bypass | Uses residential proxies for reliable access |

***

### 📈 How it compares to alternatives

| Feature | Flashscore Scraper | Manual copy-paste | Official API |
|---------|-------------------|------------------|--------------|
| Structured JSON output | Yes | No | Yes |
| Multi-sport | Yes | Manual effort | Limited |
| Date selection | Any date | Manual navigation | Yes |
| Automation | Full | None | Yes |
| Cost | Pay-per-use | Free (time cost) | Subscription |
| Setup time | 30 seconds | N/A | Hours |

***

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 in free credits
2. Open the [Flashscore Scraper actor](https://apify.com/parseforge/flashscore-scraper)
3. Configure your sport, date, and maxItems
4. Click **Start** and wait under 60 seconds
5. Download your dataset as JSON, CSV, Excel, or XML

***

### 💼 Business use cases

#### Sports Analytics Firms

Build comprehensive historical match databases for team and player performance analysis. Run the actor daily to keep your dataset current with yesterday's results across multiple sports.

#### Betting and Trading Platforms

Power your odds models with clean, structured historical match data. Export thousands of matches across leagues and dates to build training datasets for predictive models.

#### Fantasy Sports Applications

Automate daily result collection to update fantasy league standings, track player performance across matches, and power scoring engines without manual data entry.

#### Sports Media and Publishing

Quickly pull match results for articles, round-up posts, or automated score alert systems. Integrate with CMS tools via Zapier or Make to publish updates automatically.

***

### 🔌 Automating Flashscore Scraper

Connect this actor to your favorite apps using Apify's built-in integrations:

- **Make (Integromat):** Trigger a scenario whenever new match results are added to the dataset
- **Zapier:** Push match results to Google Sheets, Slack, or Airtable automatically
- **Slack:** Get daily score summaries posted to your team channel
- **Google Sheets:** Maintain a live-updating spreadsheet of match results
- **Webhook:** Send results to your own API endpoint as soon as the run completes

***

### 🌟 Beyond business use cases

#### Academic Research

Sports scientists and statisticians can build rich longitudinal datasets for studying home advantage, fatigue effects, and scheduling impacts across multiple leagues and seasons.

#### Hobby Projects and Personal Dashboards

Build your own live score dashboard, weekly league table tracker, or personal football stats app without paying for an expensive sports data API subscription.

#### Non-profit and Journalism

Investigative sports journalists can quickly pull bulk match data for research into refereeing patterns, scheduling fairness, or competitive balance across leagues.

#### Learning Data Science

Use real Flashscore match data as training material for machine learning courses - predict match outcomes, model tournament progressions, or visualize scoring distributions.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your favorite AI assistant:

- "How do I get last week's Premier League results using the Flashscore Scraper?"
- "Can I schedule this to run every day automatically?"
- "What sports does this actor support?"
- "How do I filter results to just finished matches?"

The actor outputs structured JSON that AI tools can read and analyze directly.

***

### ❓ Frequently Asked Questions

#### ❓ What sports does this actor support?

Football (soccer), tennis, basketball, hockey, and baseball.

#### ❓ Can I scrape matches from a specific date?

Yes - set the `date` field to any date in YYYY-MM-DD format. Leave it blank to default to today.

#### ❓ How many matches can I get per run?

Free users get up to 10 matches. Paid users can retrieve up to 1,000,000. Typical usage is 10-100 matches per sport per day.

#### ❓ Does this work for live scores?

Yes - running with today's date will return matches currently in play with their live scores and status.

#### ❓ Can I get match details like lineups or goal scorers?

Currently this actor returns the top-level match data (teams, score, status, tournament). Detailed match events are not included in this version.

#### ❓ How long does a run take?

Typically under 60 seconds for a full day of results for one sport.

#### ❓ Is Flashscore blocking the scraper?

The actor uses residential proxy rotation to reliably access the site. If you encounter any issues, try running again or contact ParseForge support.

#### ❓ Can I export to Excel or CSV?

Yes - Apify automatically makes all datasets downloadable as JSON, CSV, Excel, and XML from the dataset view.

#### ❓ How often can I run this?

As often as you like. Many users schedule it to run daily to keep their results database updated.

#### ❓ What timezone are the match dates in?

Match dates are returned as provided by Flashscore. The `scrapedAt` field is always in UTC.

#### ❓ What happens if no matches are found?

The actor pushes a single error record explaining that no matches were found for the given sport and date. This can happen for sports that do not have fixtures on a particular day.

***

### 🔌 Integrate with any app

This actor integrates natively with Apify's ecosystem:

- **REST API** - Call the actor programmatically and retrieve results via the Apify API
- **JavaScript/Python SDK** - Use the official Apify client libraries to automate runs
- **Make** - Build automated workflows triggered by new match data
- **Zapier** - Connect to 5,000+ apps with no code
- **Google Sheets** - Auto-populate spreadsheets with match results
- **Slack** - Post daily score summaries to any channel
- **Webhooks** - Receive real-time notifications when runs complete
- **Airbyte** - Sync sports data to your data warehouse
- **n8n** - Build complex data pipelines with open-source automation
- **Keboola** - Integrate into enterprise data stacks

***

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Sofascore Scraper](https://apify.com/parseforge/sofascore-scraper) | Live scores and match data from SofaScore |
| [ESPN Scraper](https://apify.com/parseforge/espn-scraper) | Sports news, scores, and stats from ESPN |
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database with 80+ fields |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 200+ websites across sports, real estate, jobs, finance, and more.

***

**Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or officially connected to Flashscore or its parent company Livescore Group. All data is publicly accessible on the Flashscore website. Use responsibly and in accordance with Flashscore's terms of service.

# Actor input Schema

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

Sport to scrape match results for.

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

Date to fetch results for in YYYY-MM-DD format. Defaults to today.

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

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

## Actor input object example

```json
{
  "sport": "football",
  "date": "2025-05-21",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "sport": "football",
    "date": "2025-05-21",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/flashscore-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 = {
    "sport": "football",
    "date": "2025-05-21",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/flashscore-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 '{
  "sport": "football",
  "date": "2025-05-21",
  "maxItems": 10
}' |
apify call parseforge/flashscore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flashscore Scraper | Live Sports Scores and Fixtures",
        "description": "Pull live scores, fixtures, results, and standings from Flashscore across soccer, tennis, basketball, hockey, baseball, and more. Get match details, lineups, head to head, and statistics for sports analytics, fantasy tools, betting models, and live data dashboards globally.",
        "version": "0.1",
        "x-build-id": "KwMcXVw2L6SClJ3r7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~flashscore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-flashscore-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~flashscore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-flashscore-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~flashscore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-flashscore-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": {
                    "sport": {
                        "title": "Sport",
                        "enum": [
                            "football",
                            "tennis",
                            "basketball",
                            "hockey",
                            "baseball"
                        ],
                        "type": "string",
                        "description": "Sport to scrape match results for.",
                        "default": "football"
                    },
                    "date": {
                        "title": "Date",
                        "type": "string",
                        "description": "Date to fetch results for in YYYY-MM-DD format. Defaults to today."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
