# TVMaze Scraper — TV Shows, Episodes, Cast & Schedule API (`logiover/tvmaze-scraper`) Actor

TV show data API powered by the open TVMaze REST API — no key, no browser. Search shows, pull show details, ratings, full episode lists, cast & characters, people and a country's daily TV air schedule. Export TV datasets to JSON, CSV or Excel for analytics, ML and recommendations.

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

## Pricing

from $3.50 / 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

## TVMaze Scraper — TV Show Data API (Shows, Episodes, Cast & Schedule)

A **TVMaze scraper** and structured **TV show data API** in a single Apify actor. Search TV shows, pull full show details and ratings, complete episode lists, cast and characters, people, and a whole country's daily TV air schedule — powered directly by the free, open **TVMaze REST API**. No API key, no login, no App Store Connect, no headless browser — just fast HTTP and clean, flat JSON you can export to CSV, Excel or JSON.

This **TV database API** is built for data teams, TV and streaming analysts, recommendation-engine developers, machine-learning practitioners, journalists and AI agents who need reliable, structured **TV show metadata** on demand. Seven modes share one input form, and every result is tagged with `_mode` so you can mix modes in a single dataset and filter later.

### What you get

- **Show index** — crawl the entire TVMaze catalogue, 250 shows per page, paginated through the full result set. The fastest way to build a **complete TV shows dataset**.
- **Ratings** — the TVMaze `rating` average on every show and episode.
- **Show details** — `name`, `type`, `language`, `genres[]`, `status`, `premiered`/`ended`, `runtime`, `network`, `officialSite`, `imdbId`, `thetvdbId`, poster `image`, and an HTML-stripped `summary`. Optionally embed the cast.
- **Episodes** — every episode of a series with `season`, `number`, `airdate`, `airtime`, `runtime`, per-episode rating and summary.
- **Cast & characters** — each cast member (actor) mapped to the `character` they play, with `self`/`voice` flags and photos.
- **Schedule** — a full day of TV airings for any country, joined to the show that airs (network, genres, rating).
- **People** — `name`, `country`, `birthday`, `deathday`, `gender` and photo, by free-text search or by ID.
- **Universal** — clean `url` back to TVMaze, plus `_mode` and `scrapedAt` (ISO 8601) on every item.

Export everything as **CSV, JSON, Excel (XLSX)**, HTML, RSS or JSON Lines. Six pre-built dataset views (Overview, Shows, Episodes, Cast, Schedule, People) let you slice the data with zero post-processing.

#### The 7 modes

| Mode | What it returns |
|---|---|
| `showIndex` | The whole TVMaze catalogue, 250 shows/page, paginated (highest volume) |
| `searchShows` | Free-text search for TV shows by name |
| `showDetails` | Full details for one or many show IDs (batch), optional cast embed |
| `episodes` | Every episode of a series, with season/episode numbers and ratings |
| `cast` | Cast members and the characters they play, for a show |
| `schedule` | A full day of TV airings for a country (100+ across the US) |
| `people` | Free-text people search, or details for one/more person IDs |

### Use cases

- **TV & streaming analytics** — build a **TV shows dataset** with genres, networks, premiere years and ratings, then chart trends in a BI tool.
- **Recommendation engines & ML** — bulk-ingest shows, genres, ratings and cast to train content-based or collaborative recommenders.
- **EPG / what's-on apps** — pull a country's daily **TV schedule** to power an electronic program guide or "what's on tonight" feature.
- **Catalog enrichment** — enrich your own media catalog with TVMaze metadata, posters, runtimes, networks and IMDb/TheTVDB cross-IDs via `showDetails`.
- **Market & competitor research** — track which networks air the most shows, benchmark a series' episode ratings, or monitor a genre's back catalog.
- **AI agents & RAG** — wrap the actor as a tool so an LLM can answer "what sci-fi shows air on the BBC?" or embed show summaries for retrieval.

### How to use

1. Open the actor and pick a **Mode**.
2. Fill the fields that mode needs — the input form shows which apply:
   - **showIndex**: optionally set `startPage` and `maxResults` — that's it.
   - **searchShows / people**: set `query` (a show or person name).
   - **showDetails / episodes / cast**: set a numeric `showId` like `169` (showDetails also accepts a batch, plus `embedCast`).
   - **schedule**: set `country` (e.g. `US`) and optionally `date` (`YYYY-MM-DD`).
   - **people** (by ID): set `personId` or a batch of `personIds`.
3. Optionally set `maxResults`.
4. Run the actor and export results as CSV, JSON or Excel — or pull them via the Apify API.

Example — crawl the catalogue for a big TV shows dataset:

```json
{
  "mode": "showIndex",
  "startPage": 0,
  "maxResults": 500
}
````

Example — every episode of a long-running series:

```json
{
  "mode": "episodes",
  "showId": "83",
  "maxResults": 2000
}
```

Call it from your stack via the Apify API (`run-sync-get-dataset-items`), the JavaScript/Python clients, or no-code tools like Make, n8n and Zapier.

### FAQ

#### Do I need a TVMaze API key or account?

No. TVMaze offers a free, open REST API and this actor reads it directly. You only need an Apify account — no TVMaze API key, no OAuth, no login.

#### Is this a TVMaze API or a TV database API alternative?

Both, effectively. It works as a convenient wrapper over the **TVMaze API** and as a practical **TV database API** for teams who want structured JSON, ready-made CSV/Excel exports and dataset views without writing their own pagination and flattening.

#### How do I scrape TV episodes without an API key?

Pick `episodes` mode and set the numeric `showId` (for example `83` for a long-running animated series). The actor returns every episode with season and episode numbers, air dates, runtimes, per-episode ratings and summaries — no key or login required.

#### How do I get a TVMaze show ID or person ID?

A show ID is the integer in a TVMaze show URL (`tvmaze.com/shows/169/...` → `169`). A person ID is the integer in a person URL (`tvmaze.com/people/1/...` → `1`). Use `searchShows` or `people` search first to discover IDs, then feed them into `showDetails`, `episodes`, `cast` or `people`.

#### How do I export TV show data to CSV, JSON or Excel?

Run any mode and download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSON Lines from the run page, or pull it via the Apify API. This makes it a simple **TV show data export** and TV dataset tool.

#### How do I get a TV schedule / what's-on-tonight API?

Use `schedule` mode with a `country` code (e.g. `US`, `GB`) and an optional `date`. A single US day returns well over 100 airings, each joined to its show (network, genres, rating) — perfect for an EPG or "what's on" feature.

#### How much data can the show index return?

`showIndex` paginates the entire TVMaze catalogue at 250 shows per page. A single run can pull thousands of shows in one dataset — just raise `maxResults`. It's the guaranteed high-volume mode and the default.

#### Does it cover cast and characters?

Yes. Use `cast` mode with a `showId` to get every cast member mapped to the character they play (with `self`/`voice` flags and photos), or set `embedCast: true` in `showDetails` to attach a compact cast list to each show.

#### Can I get IMDb and TheTVDB IDs too?

Yes. Every show row includes `imdbId` and `thetvdbId` cross-reference IDs from TVMaze's `externals`, so you can join TVMaze data to IMDb or TheTVDB datasets.

### Support

Open an issue on the actor page for bugs, feature requests, or custom modifications. Responses typically within 24 hours.

### 📝 Changelog

#### 2026-07-01

- Initial release: seven TVMaze modes (show index, search shows, show details, episodes, cast, schedule, people) over the open TVMaze REST API — no key, no browser.

# Actor input Schema

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

Which TVMaze endpoint to run.

• **showIndex** — the full TVMaze catalogue, 250 shows per page, paginated (highest volume — default)
• **searchShows** — free-text search for TV shows by name
• **showDetails** — full details for one or more show IDs (batch), optional cast embed
• **episodes** — every episode of a series (a long-running show returns hundreds)
• **cast** — cast members and the characters they play, for a show
• **schedule** — a full day of TV airings for a country (100+ across the US)
• **people** — free-text people search, or details for one/more person IDs

## `query` (type: `string`):

Free-text term for **searchShows** (a show name) or **people** (a person name).

## `showId` (type: `string`):

TVMaze show ID (a plain integer), e.g. `169` (Breaking Bad) or `83` (The Simpsons). Used by **showDetails**, **episodes**, **cast**. It is the number in a TVMaze show URL: tvmaze.com/shows/**169**/…

## `showIds` (type: `array`):

Array of TVMaze show IDs (integers) for batch **showDetails**.

## `embedCast` (type: `boolean`):

When true, **showDetails** also attaches a compact `cast[]` list (actor + character) to each show via `?embed[]=cast`.

## `personId` (type: `string`):

TVMaze person ID (an integer), e.g. `1`. Used by **people** mode. It is the number in a TVMaze person URL: tvmaze.com/people/**1**/…

## `personIds` (type: `array`):

Array of TVMaze person IDs (integers) for batch **people** lookups.

## `country` (type: `string`):

ISO 3166-1 alpha-2 country code for **schedule** mode, e.g. `US`, `GB`, `DE`, `TR`. A full US day returns 100+ airings.

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

Day to pull the **schedule** for, format `YYYY-MM-DD`. Leave empty for today.

## `startPage` (type: `integer`):

Page number to start the **showIndex** pagination from (0-based). Each page is 250 shows. Use it to resume or skip ahead through the catalogue.

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

Upper bound on rows returned. For showIndex this drives pagination through the catalogue; for other modes it caps the returned list.

## Actor input object example

```json
{
  "mode": "showIndex",
  "query": "breaking bad",
  "showId": "169",
  "showIds": [
    "169",
    "82",
    "83"
  ],
  "embedCast": false,
  "personId": "1",
  "personIds": [],
  "country": "US",
  "date": "2024-01-10",
  "startPage": 0,
  "maxResults": 250
}
```

# Actor output Schema

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

Full results dataset. Use the Shows view for show/search modes, Episodes for episode lists, Cast for cast, Schedule for daily airings, and People for person lookups.

# 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 = {
    "mode": "showIndex",
    "showIds": [
        "169",
        "82",
        "83"
    ],
    "country": "US",
    "maxResults": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/tvmaze-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 = {
    "mode": "showIndex",
    "showIds": [
        "169",
        "82",
        "83",
    ],
    "country": "US",
    "maxResults": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/tvmaze-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 '{
  "mode": "showIndex",
  "showIds": [
    "169",
    "82",
    "83"
  ],
  "country": "US",
  "maxResults": 250
}' |
apify call logiover/tvmaze-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TVMaze Scraper — TV Shows, Episodes, Cast & Schedule API",
        "description": "TV show data API powered by the open TVMaze REST API — no key, no browser. Search shows, pull show details, ratings, full episode lists, cast & characters, people and a country's daily TV air schedule. Export TV datasets to JSON, CSV or Excel for analytics, ML and recommendations.",
        "version": "1.0",
        "x-build-id": "zkzs6zJ9vUM7PILsc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~tvmaze-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-tvmaze-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/logiover~tvmaze-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-tvmaze-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/logiover~tvmaze-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-tvmaze-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "showIndex",
                            "searchShows",
                            "showDetails",
                            "episodes",
                            "cast",
                            "schedule",
                            "people"
                        ],
                        "type": "string",
                        "description": "Which TVMaze endpoint to run.\n\n• **showIndex** — the full TVMaze catalogue, 250 shows per page, paginated (highest volume — default)\n• **searchShows** — free-text search for TV shows by name\n• **showDetails** — full details for one or more show IDs (batch), optional cast embed\n• **episodes** — every episode of a series (a long-running show returns hundreds)\n• **cast** — cast members and the characters they play, for a show\n• **schedule** — a full day of TV airings for a country (100+ across the US)\n• **people** — free-text people search, or details for one/more person IDs",
                        "default": "showIndex"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text term for **searchShows** (a show name) or **people** (a person name)."
                    },
                    "showId": {
                        "title": "Show ID",
                        "type": "string",
                        "description": "TVMaze show ID (a plain integer), e.g. `169` (Breaking Bad) or `83` (The Simpsons). Used by **showDetails**, **episodes**, **cast**. It is the number in a TVMaze show URL: tvmaze.com/shows/**169**/…"
                    },
                    "showIds": {
                        "title": "Show IDs (batch, showDetails)",
                        "type": "array",
                        "description": "Array of TVMaze show IDs (integers) for batch **showDetails**.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "embedCast": {
                        "title": "Embed cast (showDetails)",
                        "type": "boolean",
                        "description": "When true, **showDetails** also attaches a compact `cast[]` list (actor + character) to each show via `?embed[]=cast`.",
                        "default": false
                    },
                    "personId": {
                        "title": "Person ID (people)",
                        "type": "string",
                        "description": "TVMaze person ID (an integer), e.g. `1`. Used by **people** mode. It is the number in a TVMaze person URL: tvmaze.com/people/**1**/…"
                    },
                    "personIds": {
                        "title": "Person IDs (batch)",
                        "type": "array",
                        "description": "Array of TVMaze person IDs (integers) for batch **people** lookups.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "country": {
                        "title": "Country (schedule)",
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code for **schedule** mode, e.g. `US`, `GB`, `DE`, `TR`. A full US day returns 100+ airings.",
                        "default": "US"
                    },
                    "date": {
                        "title": "Date (schedule, YYYY-MM-DD)",
                        "type": "string",
                        "description": "Day to pull the **schedule** for, format `YYYY-MM-DD`. Leave empty for today."
                    },
                    "startPage": {
                        "title": "Start page (showIndex)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Page number to start the **showIndex** pagination from (0-based). Each page is 250 shows. Use it to resume or skip ahead through the catalogue.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Upper bound on rows returned. For showIndex this drives pagination through the catalogue; for other modes it caps the returned list.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```