# NHK Video Scraper (`hgservices/nhk-video-scraper`) Actor

Scrape NHK WORLD-JAPAN on-demand videos to get video links and metadata: title, series, thumbnail, duration, and dates. Works with a single video, a whole program, a category, or the entire catalog. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/hgservices/nhk-video-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** Videos, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## NHK Video Scraper

**Scrape [NHK WORLD-JAPAN](https://www3.nhk.or.jp/nhkworld/en/ondemand/) on-demand videos and get video links plus clean metadata** - title, series, description, thumbnail, duration, and broadcast and expiry dates. Point it at a single video page, a whole program, a category, or the entire on-demand catalog, and get back a structured dataset you can export as JSON, CSV, or Excel, or pull via the Apify API.

NHK WORLD-JAPAN is the international service of Japan's public broadcaster (NHK), streaming free documentaries, culture, food, anime, and news programs. Use this scraper to build datasets of NHK video content in **seconds**, without copy-pasting anything by hand.

### What does NHK Video Scraper do?

- Collects the **video link** for each NHK WORLD-JAPAN on-demand video.
- Extracts **metadata**: title, series/program, description, thumbnail, duration, categories, tags, caption and audio languages, first-broadcast date, and the date the video expires from on-demand.
- Accepts a **single video**, a **whole program**, a **category**, a **tag**, or the **entire on-demand catalog** - and automatically collects every video on listing pages.
- Runs on the Apify platform with **scheduling, API access, integrations, and monitoring** built in.

### Why use NHK Video Scraper?

- **Media monitoring & archiving** - track NHK WORLD-JAPAN coverage of a topic or program in one dataset.
- **Research & journalism** - build datasets of NHK video metadata for analysis.
- **Content pipelines** - feed video links and metadata into your own tools and workflows.
- **Bulk collection** - grab an entire program or category in a single run instead of page by page.

### How to use NHK Video Scraper

1. Open the Actor in Apify Console.
2. In the **Input** tab, add one or more **Start URLs** - a video page, a program page, a category page, or the on-demand catalog (see examples below).
3. Optionally set **Max videos** to cap how many items are scraped.
4. Click **Start**.
5. When the run finishes, open the **Output/Dataset** tab and export as JSON, CSV, HTML, or Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | NHK WORLD-JAPAN video, program, category, tag, or on-demand catalog URLs. Required. |
| `maxItems` | integer | Maximum number of videos to scrape (`0` = unlimited). Default `50`. |
| `crawlListingPages` | boolean | Collect the videos found on program/category/catalog pages. Default `true`. Turn off to scrape only the exact video URLs you provide. |
| `downloadVideos` | boolean | Download each video as a ready-to-play **MP4** file and add a clickable download link to the results. Default `false`. See [Download videos as MP4](#download-videos-as-mp4). |
| `proxyConfiguration` | object | Optional proxy settings. |

#### Download videos as MP4

By default the Actor returns a `streamUrl` - an HLS stream link (`.m3u8`) that plays in media tools but is **not** a single downloadable file. If you just want to click a link and save the video, turn on **Download video files (MP4)**.

When enabled, the Actor downloads each video, converts it to a standard **MP4**, and stores it. A **Video file (MP4)** link then appears in the results (the `videoFile` field) - click it to download the video straight to your computer. No ffmpeg, yt-dlp, or other technical tools required.

```json
{
  "startUrls": [{ "url": "https://www3.nhk.or.jp/nhkworld/en/shows/2049165/" }],
  "maxItems": 5,
  "downloadVideos": true
}
````

> **Heads-up on speed and cost:** downloading full videos is far slower and more expensive than the default metadata-only scrape (a single 28-minute episode is roughly 250-300 MB). Always pair `downloadVideos` with a sensible **Max videos** cap, and only download content you are permitted to store - see the disclaimer below.

#### Supported start URLs

All URLs live under `https://www3.nhk.or.jp/nhkworld/<lang>/` (e.g. `en`, `es`, `zh`):

| URL shape | Example | What it scrapes |
|---|---|---|
| Video page | `.../nhkworld/en/shows/2049165/` | That single video |
| Video page (alt) | `.../nhkworld/en/shows/video/2049165/` | That single video |
| Clip page | `.../nhkworld/en/ondemand/video/9999011/` | That single clip (ids starting `9999`) |
| Program page | `.../nhkworld/en/shows/japanrailway/` | Every episode of the program |
| Category page | `.../nhkworld/en/shows/category/14/` | Every video in the category |
| Tag page | `.../nhkworld/en/shows/tag/2/` | Every video with the tag |
| On-demand catalog | `.../nhkworld/en/ondemand/` | The whole on-demand catalog |

#### Example inputs

**Scrape a whole program:**

```json
{
  "startUrls": [{ "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/" }],
  "maxItems": 25,
  "crawlListingPages": true
}
```

**Scrape specific video pages only:** when you already have exact video URLs, turn off listing discovery.

```json
{
  "startUrls": [
    { "url": "https://www3.nhk.or.jp/nhkworld/en/shows/2049165/" },
    { "url": "https://www3.nhk.or.jp/nhkworld/en/shows/2049176/" }
  ],
  "crawlListingPages": false
}
```

**Scrape an entire category, unlimited:**

```json
{
  "startUrls": [{ "url": "https://www3.nhk.or.jp/nhkworld/en/shows/category/14/" }],
  "maxItems": 0
}
```

### Output

Each dataset item represents one NHK WORLD-JAPAN video:

```json
{
  "url": "https://www3.nhk.or.jp/nhkworld/en/shows/2049165/",
  "id": "2049165",
  "lang": "en",
  "type": "episode",
  "title": "Choshi Electric Railway: Fighting to Get Back on Track",
  "seriesTitle": "Japan Railway Journal",
  "programId": "japanrailway",
  "description": "Choshi Electric Railway in Chiba Prefecture posted its first loss in four years...",
  "thumbnailUrl": "https://www3.nhk.or.jp/nhkworld/en/shows/2049165/images/wide_l_....jpg",
  "streamUrl": "https://masterpl.hls.nhkworld.jp/hls/w/204916520260416001/master.m3u8",
  "videoFile": "https://api.apify.com/v2/key-value-stores/<storeId>/records/video-2049165",
  "durationSeconds": 1680,
  "firstBroadcastAt": "2025-09-25T14:30:00Z",
  "publishedAt": "2026-04-16T14:58:00Z",
  "expiredAt": "2026-09-24T14:59:00Z",
  "isExpired": false,
  "category": "Biz & Tech",
  "categories": ["Biz & Tech"],
  "tags": ["Akita", "Chiba", "Trains", "Transcript"],
  "captionLangs": ["zt", "hi", "pt", "es", "vi"],
  "voiceLangs": ["en"]
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data table

| Field | Description |
|---|---|
| `url` | The NHK WORLD-JAPAN video page URL. |
| `id` | NHK's on-demand video id. |
| `lang` | Language of the requested version (e.g. `en`). |
| `type` | `episode` or `clip`. |
| `title` | Video title. |
| `seriesTitle` | Program / series the video belongs to. |
| `programId` | NHK's program name (e.g. `japanrailway`). |
| `description` | Short synopsis. |
| `thumbnailUrl` | Largest available poster image. |
| `streamUrl` | The video stream link (HLS `.m3u8`). |
| `videoFile` | Direct download link to the MP4 file. Populated only when **Download video files** is on, otherwise `null`. |
| `durationSeconds` | Duration in whole seconds. |
| `firstBroadcastAt` | When the program first aired. |
| `publishedAt` | When the on-demand video became available. |
| `expiredAt` | When the video leaves on-demand. |
| `isExpired` | `true` if the video is already past its expiry. |
| `category` / `categories` | NHK content category (first, and full list). |
| `tags` | Topic/region tags. |
| `captionLangs` / `voiceLangs` | Available subtitle and audio languages. |

### How much does it cost to scrape NHK videos?

The default metadata scrape is lightweight, so runs are fast and cheap - typically a fraction of a compute unit for dozens of videos. To control cost on large jobs, set **Max videos** and consider running on a schedule for incremental captures. Apify's free tier is enough to try it and to run small jobs.

Turning on **Download video files (MP4)** changes this significantly: each full video (roughly 250-300 MB for a 28-minute episode) has to be downloaded and stored, so runs take much longer, use more compute, and consume storage. Keep **Max videos** low when downloading, and remove stored MP4s you no longer need.

### Tips & advanced options

- **Scrape a whole show or category**: pass its page as a start URL and leave **Discover videos on listing pages** on to collect every video.
- **Scrape exact videos only**: paste the specific video URLs and turn **Discover videos on listing pages** off.
- **Cap cost**: use **Max videos**.
- **Other languages**: NHK WORLD-JAPAN publishes many programs in languages beyond English - just use the matching URL, e.g. `.../nhkworld/es/...`.

### FAQ, disclaimers & support

**What is the `streamUrl`?** It is the link to the video stream, in the standard HLS format (`.m3u8`) that most video players and media tools support. It's the same stream NHK's own player uses.

**How do I actually download the video file?** The `streamUrl` is a *stream*, not a file - opening it in a browser saves a small playlist, not the video. To get a real, playable video file, turn on **Download video files (MP4)**; the Actor then adds a **Video file (MP4)** link (`videoFile`) you can click to download the video directly. See [Download videos as MP4](#download-videos-as-mp4).

**Why is a video missing a `streamUrl`?** NHK on-demand videos are available for a limited time. Once a video passes its expiry date, its stream is removed; the Actor still returns the metadata with `isExpired: true`.

**Is scraping NHK legal?** This Actor collects publicly available information that NHK WORLD-JAPAN publishes on its on-demand service. You are responsible for complying with [NHK's Terms of Service](https://www3.nhk.or.jp/nhkworld/en/terms/) and applicable copyright law, and for how you use any content. Do not redistribute copyrighted video without permission.

**Found a bug or need a custom solution?** Open an issue in the Actor's **Issues** tab.

# Actor input Schema

## `startUrls` (type: `array`):

NHK WORLD-JAPAN URLs to scrape. These can be individual on-demand video pages (e.g. https://www3.nhk.or.jp/nhkworld/en/shows/2049165/), a program page (https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/), a category page (https://www3.nhk.or.jp/nhkworld/en/shows/category/14/), or the on-demand catalog (https://www3.nhk.or.jp/nhkworld/en/ondemand/) - listing pages are crawled to discover the video pages they contain.

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

Maximum number of video items to scrape (0 = unlimited). Useful to cap cost when crawling large program, category, or catalog pages.

## `crawlListingPages` (type: `boolean`):

When a start URL is a program, category, tag, or catalog page (not a direct video page), follow the video pages found on it. Turn off to scrape only the exact video URLs you provide.

## `downloadVideos` (type: `boolean`):

When enabled, each video is downloaded and saved as a ready-to-play MP4 file. A clickable 'Video file (MP4)' link then appears in the results - just click it to download the video, no technical tools needed. Leave this OFF for a fast, cheap metadata-only run (you only get the HLS stream link, which needs a downloader like ffmpeg/yt-dlp). Turning this ON makes runs much slower and more expensive, since full videos are downloaded - use the 'Max videos' cap to control cost.

## `proxyConfiguration` (type: `object`):

Proxy settings. NHK's on-demand API is public and lightweight, so a proxy is optional, but Apify Proxy can help with rate limiting on large runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/"
    }
  ],
  "maxItems": 50,
  "crawlListingPages": true,
  "downloadVideos": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/nhk-video-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 = { "startUrls": [{ "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/" }] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/nhk-video-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 '{
  "startUrls": [
    {
      "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/"
    }
  ]
}' |
apify call hgservices/nhk-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHK Video Scraper",
        "description": "Scrape NHK WORLD-JAPAN on-demand videos to get video links and metadata: title, series, thumbnail, duration, and dates. Works with a single video, a whole program, a category, or the entire catalog. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "cMdJVk1gkjVpinHa3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~nhk-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-nhk-video-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/hgservices~nhk-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-nhk-video-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/hgservices~nhk-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-nhk-video-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "NHK WORLD-JAPAN URLs to scrape. These can be individual on-demand video pages (e.g. https://www3.nhk.or.jp/nhkworld/en/shows/2049165/), a program page (https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/), a category page (https://www3.nhk.or.jp/nhkworld/en/shows/category/14/), or the on-demand catalog (https://www3.nhk.or.jp/nhkworld/en/ondemand/) - listing pages are crawled to discover the video pages they contain.",
                        "default": [
                            {
                                "url": "https://www3.nhk.or.jp/nhkworld/en/shows/japanrailway/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max videos",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of video items to scrape (0 = unlimited). Useful to cap cost when crawling large program, category, or catalog pages.",
                        "default": 50
                    },
                    "crawlListingPages": {
                        "title": "Discover videos on listing pages",
                        "type": "boolean",
                        "description": "When a start URL is a program, category, tag, or catalog page (not a direct video page), follow the video pages found on it. Turn off to scrape only the exact video URLs you provide.",
                        "default": true
                    },
                    "downloadVideos": {
                        "title": "Download video files (MP4)",
                        "type": "boolean",
                        "description": "When enabled, each video is downloaded and saved as a ready-to-play MP4 file. A clickable 'Video file (MP4)' link then appears in the results - just click it to download the video, no technical tools needed. Leave this OFF for a fast, cheap metadata-only run (you only get the HLS stream link, which needs a downloader like ffmpeg/yt-dlp). Turning this ON makes runs much slower and more expensive, since full videos are downloaded - use the 'Max videos' cap to control cost.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. NHK's on-demand API is public and lightweight, so a proxy is optional, but Apify Proxy can help with rate limiting on large runs.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
