# Livesport Scores & Fixtures Scraper (`automation-lab/livesport-scores-fixtures-scraper`) Actor

Extract live scores, fixtures, final results, league metadata, team IDs, match URLs, and optional odds-link context from Livesport scoreboards.

- **URL**: https://apify.com/automation-lab/livesport-scores-fixtures-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **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.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

## Livesport Scores & Fixtures Scraper

Extract live scores, fixtures, final results, league metadata, team IDs, match URLs, and optional odds-link context from public Livesport scoreboards.

### What does Livesport Scores & Fixtures Scraper do?

Livesport Scores & Fixtures Scraper turns public Livesport scoreboard feeds into clean Apify dataset rows.

It is built for recurring sports monitoring workflows where teams need structured match data without manually checking the Livesport website.

The actor can collect:

- ⚽ today's soccer scoreboard
- 🕒 upcoming fixtures
- ✅ finished results
- 🔴 live matches
- 🏆 country and league metadata
- 👥 home and away team names
- 🔢 current or final scores
- 🧩 period score fragments when available
- 🔗 match and league URLs
- 💸 optional odds/bookmaker link context

### Who is it for?

#### Sports analytics teams

Use the actor to collect daily fixtures and results for downstream models, dashboards, or quality-control checks.

#### Betting research teams

Monitor public scoreboards, match IDs, team metadata, and optional bookmaker links for pre-match or post-match workflows.

#### Fantasy and media teams

Track schedules and final results across leagues so editors and fantasy operations can prepare alerts and coverage.

#### Data engineering teams

Run it on a schedule, export JSON/CSV, and load match rows into a warehouse.

### Why use this actor?

Livesport is broad, fast, and widely used by sports fans.

This actor focuses on the stable public scoreboard feed instead of expensive browser automation.

That means:

- lower compute costs
- faster runs
- fewer moving browser parts
- predictable dataset columns
- simple scheduled monitoring

### Data fields

| Field | Description |
| --- | --- |
| `sportId` | Livesport numeric sport ID |
| `sportName` | Sport slug/name used for generated URLs |
| `country` | Country or category name |
| `league` | Competition name |
| `leagueUrl` | Public Livesport league URL when present |
| `tournamentId` | Feed tournament identifier |
| `matchId` | Livesport match identifier |
| `matchUrl` | Generated public match URL |
| `homeTeam` | Home participant name |
| `awayTeam` | Away participant name |
| `homeTeamId` | Feed home team ID |
| `awayTeamId` | Feed away team ID |
| `homeScore` | Current/final home score when available |
| `awayScore` | Current/final away score when available |
| `homePeriodScores` | Period score fragments for home side |
| `awayPeriodScores` | Period score fragments for away side |
| `statusCode` | Raw Livesport status code |
| `statusText` | Human-readable status bucket |
| `startTimestamp` | ISO start time |
| `startTimestampUnix` | Unix start time in seconds |
| `homeSlug` | Home team slug |
| `awaySlug` | Away team slug |
| `homeLogoUrl` | Home logo asset URL |
| `awayLogoUrl` | Away logo asset URL |
| `oddsLinks` | Optional bookmaker/link metadata |
| `sourceFeedUrl` | Feed URL used for the row |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Livesport scores and fixtures?

The actor uses pay-per-event pricing.

You pay a small run-start fee and then a per-match event for each dataset row produced.

Because this is an HTTP-first actor, typical scoreboards are designed to be inexpensive compared with browser-based scraping.

Use small `maxItems` values for testing.

Raise `maxItems` for complete daily scoreboards or scheduled production runs.

### How to use it

1. Open the actor on Apify.
2. Choose a `sportId`.
3. Keep `sportName` aligned with that sport.
4. Choose one or more `dateOffsets`.
5. Select `mode` if you only need live, finished, or scheduled matches.
6. Optionally add a country or league filter.
7. Run the actor.
8. Export the dataset as JSON, CSV, Excel, RSS, or via API.

### Input options

#### `sportId`

Livesport internal sport ID.

Common values include:

- `1` soccer
- `2` tennis
- `3` basketball
- `4` hockey
- `13` baseball
- `16` American football

#### `sportName`

A readable sport slug used in generated match URLs.

For soccer, leave the default `soccer`.

#### `dateOffsets`

Relative days to scrape.

Examples:

- `[0]` today
- `[-1]` yesterday
- `[1]` tomorrow
- `[-1, 0, 1]` yesterday, today, and tomorrow

#### `mode`

Filter after fetching the scoreboard.

Available values:

- `all`
- `live`
- `finished`
- `scheduled`

#### `maxItems`

Maximum number of match rows to emit.

#### `countryFilter`

Case-insensitive country text filter.

Example: `Brazil`.

#### `leagueFilter`

Case-insensitive league text filter.

Example: `Serie B`.

#### `includeOddsLinks`

When enabled, the actor parses optional Livesport link metadata if present in the feed.

### Example input

```json
{
  "sportId": 1,
  "sportName": "soccer",
  "dateOffsets": [0],
  "mode": "all",
  "maxItems": 100,
  "includeOddsLinks": false
}
````

### Example output

```json
{
  "sportId": 1,
  "sportName": "soccer",
  "country": "Brazil",
  "league": "Serie B",
  "matchId": "MsKPu55e",
  "matchUrl": "https://www.livesport.com/en/match/soccer/athletic-club-operario-pr/MsKPu55e/",
  "homeTeam": "Athletic Club",
  "awayTeam": "Operario-PR",
  "homeScore": 0,
  "awayScore": 1,
  "statusText": "finished",
  "startTimestamp": "2026-07-08T03:00:00.000Z",
  "oddsLinks": []
}
```

### Tips for reliable runs

- Start with `maxItems: 100` for validation.
- Use `dateOffsets: [-1]` with `mode: finished` for results.
- Use `dateOffsets: [1]` with `mode: scheduled` for fixtures.
- Keep `includeOddsLinks` off unless you need link context.
- Use filters after confirming the country and league names in the output.

### Integrations

#### Sports warehouse refresh

Schedule the actor daily and export results to your database.

#### Betting research notebook

Call the actor from Python and merge match IDs with internal odds or prediction data.

#### Editorial monitoring

Run the actor every few minutes with `mode: live` and alert on changed match status.

#### BI dashboards

Connect the dataset to Google Sheets, Make, Zapier, or your own ETL.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/livesport-scores-fixtures-scraper').call({
  sportId: 1,
  sportName: 'soccer',
  dateOffsets: [0],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/livesport-scores-fixtures-scraper').call(run_input={
    'sportId': 1,
    'sportName': 'soccer',
    'dateOffsets': [0],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~livesport-scores-fixtures-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"sportId":1,"sportName":"soccer","dateOffsets":[0],"maxItems":100}'
```

### MCP usage

Use this actor from Claude or other MCP-compatible tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/livesport-scores-fixtures-scraper
```

Claude Code setup:

```bash
claude mcp add apify-livesport https://mcp.apify.com/?tools=automation-lab/livesport-scores-fixtures-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape today's soccer fixtures from Livesport and summarize matches by country."
- "Get finished Livesport soccer results from yesterday and return CSV-ready rows."
- "Monitor live Livesport soccer matches and flag games with non-null scores."

### Related scrapers

Other automation-lab actors that may complement this workflow:

- https://apify.com/automation-lab/espn-news-scraper
- https://apify.com/automation-lab/ufcstats-scraper
- https://apify.com/automation-lab/google-news-scraper

### Limitations

The MVP focuses on scoreboard rows.

It does not yet open every match detail tab for lineups, incidents, or statistics.

Public feed structure can change.

When Livesport does not include a field in the scoreboard feed, the actor returns `null` or an empty array.

### Legality

This actor extracts publicly available data.

Always use it responsibly and respect Livesport terms, robots guidance, and applicable laws.

Do not collect personal data unless you have a lawful basis.

### FAQ

#### Why did I get fewer rows than expected?

Check `maxItems`, `mode`, `countryFilter`, and `leagueFilter`.

A restrictive filter can remove rows after the feed is fetched.

#### Why are odds links empty?

Livesport only includes link metadata for some matches and regions.

Set `includeOddsLinks` to `true` if you need this optional field.

#### Why are scores null for fixtures?

Scheduled fixtures usually do not have scores yet.

Use `mode: finished` for final result rows.

### Changelog

#### 0.1

Initial HTTP-first Livesport scoreboard scraper with date offsets, status filtering, league/team metadata, scores, match URLs, and optional odds links.

### Support

If you need another sport ID, additional match-detail tabs, or a new output field, open an Apify issue on the actor page with an example Livesport URL and desired dataset columns.

# Actor input Schema

## `sportId` (type: `integer`):

Livesport internal sport ID. Common values: 1 soccer, 2 tennis, 3 basketball, 4 hockey, 13 baseball, 16 American football.

## `sportName` (type: `string`):

Human-readable sport slug used in generated Livesport match URLs.

## `dateOffsets` (type: `array`):

Relative days to scrape from the Livesport scoreboard. 0=today, -1=yesterday/results, 1=tomorrow/fixtures.

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

Filter matches by status after fetching the scoreboard.

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

Stop after this many match records. Keep small for smoke tests; raise for complete daily scoreboards.

## `countryFilter` (type: `string`):

Optional case-insensitive country text filter, for example Brazil or England.

## `leagueFilter` (type: `string`):

Optional case-insensitive league text filter, for example Serie B or Premier League.

## `includeOddsLinks` (type: `boolean`):

Parse public bookmaker/streaming/odds link metadata when Livesport includes it in the feed.

## Actor input object example

```json
{
  "sportId": 1,
  "sportName": "soccer",
  "dateOffsets": [
    0
  ],
  "mode": "all",
  "maxItems": 20,
  "includeOddsLinks": false
}
```

# 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 = {
    "sportId": 1,
    "sportName": "soccer",
    "dateOffsets": [
        0
    ],
    "mode": "all",
    "maxItems": 20,
    "countryFilter": "",
    "leagueFilter": "",
    "includeOddsLinks": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/livesport-scores-fixtures-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 = {
    "sportId": 1,
    "sportName": "soccer",
    "dateOffsets": [0],
    "mode": "all",
    "maxItems": 20,
    "countryFilter": "",
    "leagueFilter": "",
    "includeOddsLinks": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/livesport-scores-fixtures-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 '{
  "sportId": 1,
  "sportName": "soccer",
  "dateOffsets": [
    0
  ],
  "mode": "all",
  "maxItems": 20,
  "countryFilter": "",
  "leagueFilter": "",
  "includeOddsLinks": false
}' |
apify call automation-lab/livesport-scores-fixtures-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Livesport Scores & Fixtures Scraper",
        "description": "Extract live scores, fixtures, final results, league metadata, team IDs, match URLs, and optional odds-link context from Livesport scoreboards.",
        "version": "0.1",
        "x-build-id": "M9Ha1w6eoT1rHJsp3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~livesport-scores-fixtures-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-livesport-scores-fixtures-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~livesport-scores-fixtures-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-livesport-scores-fixtures-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~livesport-scores-fixtures-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-livesport-scores-fixtures-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": {
                    "sportId": {
                        "title": "Sport ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Livesport internal sport ID. Common values: 1 soccer, 2 tennis, 3 basketball, 4 hockey, 13 baseball, 16 American football.",
                        "default": 1
                    },
                    "sportName": {
                        "title": "Sport name for match URLs",
                        "type": "string",
                        "description": "Human-readable sport slug used in generated Livesport match URLs.",
                        "default": "soccer"
                    },
                    "dateOffsets": {
                        "title": "Date offsets",
                        "type": "array",
                        "description": "Relative days to scrape from the Livesport scoreboard. 0=today, -1=yesterday/results, 1=tomorrow/fixtures.",
                        "items": {
                            "type": "integer",
                            "minimum": -7,
                            "maximum": 14
                        },
                        "default": [
                            0
                        ]
                    },
                    "mode": {
                        "title": "Match mode",
                        "enum": [
                            "all",
                            "live",
                            "finished",
                            "scheduled"
                        ],
                        "type": "string",
                        "description": "Filter matches by status after fetching the scoreboard.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Maximum matches",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many match records. Keep small for smoke tests; raise for complete daily scoreboards.",
                        "default": 20
                    },
                    "countryFilter": {
                        "title": "Country filter",
                        "type": "string",
                        "description": "Optional case-insensitive country text filter, for example Brazil or England."
                    },
                    "leagueFilter": {
                        "title": "League filter",
                        "type": "string",
                        "description": "Optional case-insensitive league text filter, for example Serie B or Premier League."
                    },
                    "includeOddsLinks": {
                        "title": "Include odds links",
                        "type": "boolean",
                        "description": "Parse public bookmaker/streaming/odds link metadata when Livesport includes it in the feed.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```