# YouTube Search Scraper (`xtracto/youtube-search-scraper`) Actor

Search YouTube videos, channels, and playlists. Filter by upload date, view count, length, live, shorts. Bulk-paginated.

- **URL**: https://apify.com/xtracto/youtube-search-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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.
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

## YouTube Search Scraper

Search YouTube by keyword and stream back structured results — videos, channels, and playlists — with built-in filters for upload date, view count, content type, and live/shorts.

### Why use this actor

- **No account / no API key required** — just give it a query and the actor returns the same results YouTube shows on the web.
- **Filter the way YouTube does** — sort by relevance, upload date, view count, or rating; restrict to videos / channels / playlists; or narrow to today's or this week's uploads, live streams, or shorts.
- **Mixed result types in one stream** — videos, channels, and playlists are returned together, each tagged with a `type` discriminator so you can split them downstream.
- **No quota limits** — unlike the official YouTube Data API, runs are not capped by a daily quota; pay only for the results you receive.
- **Bulk queries in one run** — pass a list of search terms; every record is tagged with `_input` and `_filter` so you can join results back to your input list.
- **Stable JSON output** — every row carries `_input`, `_filter`, `_source`, `_scrapedAt` envelope fields, ready for pipelines, spreadsheets, and databases.

### How it works

1. You provide one or more search queries (e.g. `twice`, `python tutorial`) and pick a `filter`.
2. The actor fetches search results the same way YouTube's web app does, then paginates with continuation tokens until it has gathered `maxResults` items per query.
3. Results stream into your dataset as flat JSON records, ready to download as JSON, CSV, or Excel.

You do not need to manage scrapers, browsers, or rotating IPs — all handled internally.

### Input

```json
{
  "queries": [
    "lofi hip hop",
    "python tutorial"
  ],
  "maxResults": 20,
  "filter": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `queries` | array | One or more search queries to run. Each query is processed independently. |
| `maxResults` | integer | Maximum results returned per query. Pagination is automatic. Default: 20. Set to 0 for unlimited. |
| `filter` | string | Filter / sort mode. See table below. Default: `relevance`. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter is the default and works well for search. |

#### `filter` options

| Value | What it does |
|---|---|
| `relevance` | Default YouTube ranking (best match for the query). |
| `upload_date` | Sort by newest upload first. |
| `view_count` | Sort by most viewed first. |
| `rating` | Sort by highest-rated first. |
| `video_only` | Restrict results to videos. |
| `channel_only` | Restrict results to channels — useful for influencer discovery. |
| `playlist_only` | Restrict results to playlists. |
| `live` | Currently live streams only. |
| `short` | Videos under 4 minutes (catches most Shorts). |
| `today` | Uploaded in the last 24 hours. |
| `this_week` | Uploaded in the last 7 days. |

### Output

Input: `queries: ["twice"]`, `maxResults: 5`, `filter: "relevance"` — the actor returns a mixed stream of videos and channels:

```json
{
  "type": "video",
  "videoId": "i0p1bmr0EmE",
  "title": "TWICE \"What is Love?\" M/V",
  "channelTitle": "JYP Entertainment",
  "channelId": "UCaO6TYtlC8U5ttz62hTrZgg",
  "publishedTimeText": "8 years ago",
  "lengthText": "3:44",
  "viewCountText": "918,997,637 views",
  "descriptionSnippet": "TWICE(트와이스) \"What is Love?\" M/V Spotify https://goo.gl/jVLYYY iTunes & Apple Music https://goo.gl/DKyKZf Google Music ...",
  "thumbnails": [
    {
      "url": "https://i.ytimg.com/vi/i0p1bmr0EmE/hqdefault.jpg?sqp=-oaymwEcCOADEI4CSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLA8eBN8cI0jbqpUfPBbCVH7jph99A",
      "width": 480,
      "height": 270
    }
  ],
  "_input": "twice",
  "_filter": "relevance",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:42:57.499074+00:00"
}
```

```json
{
  "type": "channel",
  "channelId": "UCzgxx_DM2Dcb9Y1spb9mUJA",
  "title": "TWICE",
  "descriptionSnippet": "TWICE Official YouTube Channel.",
  "subscriberCountText": "19.3M subscribers",
  "thumbnails": [
    {
      "url": "https://yt3.googleusercontent.com/rj-m7CQIV8hIHx_lB8cjs0NxrDFJaUkVwZ5tCnZTNSVEr2IqXGF-2e7nr7og1IGeRXtHikce=s176-c-k-c0x00ffffff-no-rj-mo",
      "width": 176,
      "height": 176
    }
  ],
  "_input": "twice",
  "_filter": "relevance",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:42:57.499074+00:00"
}
```

```json
{
  "type": "video",
  "videoId": "FxkAkEaalB8",
  "title": "TWICE (트와이스) PLAYLIST 2025 [UPDATED]",
  "channelTitle": "FEARLIX",
  "channelId": "UCqNQp_VOtVjQBOR_OhrizMA",
  "publishedTimeText": "10 months ago",
  "lengthText": "2:52:07",
  "viewCountText": "765,898 views",
  "descriptionSnippet": "TWICE (트와이스) is a nine-member girl group under JYP Entertainment, Formed through the reality show SIXTEEN. Group ...",
  "_input": "twice",
  "_filter": "relevance",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:42:57.499074+00:00"
}
```

*… 2 more results in the same run.*

#### Common fields (every row)

| Field | Type | Description |
|---|---|---|
| `_input` | string | The query exactly as you supplied it. Use this to join results back to your input list. |
| `_filter` | string | The `filter` value used for this run (e.g. `relevance`, `upload_date`). |
| `_source` | string | Internal tag for the fetch path. `S1-primary` means the fastest, richest path; `S2-*` would indicate a fallback. |
| `_scrapedAt` | string | ISO-8601 UTC timestamp when the record was scraped. |
| `type` | string | Result type discriminator: `video`, `channel`, or `playlist`. |

#### Video fields (`type: "video"`)

| Field | Type | Description |
|---|---|---|
| `videoId` | string | YouTube video ID (the part after `watch?v=`). |
| `title` | string | Video title. |
| `channelTitle` | string | Display name of the channel that uploaded the video. |
| `channelId` | string | Channel ID (starts with `UC...`). |
| `publishedTimeText` | string | YouTube's localized upload time (e.g. `"8 years ago"`, `"3 days ago"`). |
| `lengthText` | string | Video duration as displayed (e.g. `"3:44"`, `"2:52:07"`). |
| `viewCountText` | string | View count as displayed (e.g. `"918,997,637 views"`). |
| `descriptionSnippet` | string | Short description snippet shown under the result. |
| `thumbnails` | array | Thumbnail URLs with `width` and `height`. |

#### Channel fields (`type: "channel"`)

| Field | Type | Description |
|---|---|---|
| `channelId` | string | Channel ID (starts with `UC...`). |
| `title` | string | Channel display name. |
| `descriptionSnippet` | string | Short channel description. |
| `subscriberCountText` | string | Subscriber count as displayed (e.g. `"19.3M subscribers"`). |
| `thumbnails` | array | Channel avatar URLs with `width` and `height`. |

#### Playlist fields (`type: "playlist"`)

| Field | Type | Description |
|---|---|---|
| `playlistId` | string | YouTube playlist ID. |
| `title` | string | Playlist title. |
| `videoCount` | string | Number of videos in the playlist. |
| `channelTitle` | string | Display name of the channel that owns the playlist. |

#### Error envelope

Queries that fail to fetch return a structured error instead of crashing the run:

```json
{
  "_input": "some query",
  "_error": "fetch_failed",
  "_errorDetail": "network error or upstream rejection",
  "_source": "S1-primary",
  "_scrapedAt": "2026-05-18T10:42:57.499074+00:00"
}
```

Filter on `_error` to triage failed rows.

### Pricing

This actor is billed per result: **$3.50 per 1,000 results**. Each video, channel, or playlist record = 1 result. Errors are not billed.

### Other Sosmed Actors

| Platform | Actor | Best for |
|---|---|---|
| YouTube | [YouTube Channel Scraper](https://apify.com/xtracto/youtube-channel-scraper) | Pull a channel's full upload list + metadata |
| YouTube | [YouTube Video Detail Scraper](https://apify.com/xtracto/youtube-video-detail-scraper) | Full metadata, description, and stats for any video |
| Bluesky | [Bluesky Search Scraper](https://apify.com/xtracto/bluesky-search-scraper) | Keyword search across the Bluesky timeline |
| Reddit | [Reddit Search Scraper](https://apify.com/xtracto/reddit-search-scraper) | Search posts across all subreddits |
| X / Twitter | [X Search Scraper](https://apify.com/xtracto/x-search-scraper) | Keyword search across X posts |
| Tumblr | [Tumblr Blog Scraper](https://apify.com/xtracto/tumblr-blog-scraper) | Pull posts from any Tumblr blog |

Browse the full catalog at [apify.com/xtracto](https://apify.com/xtracto).

### Notes

- **Result freshness** — YouTube ranks search results dynamically; the same query rerun a few minutes later may return a slightly different order. Use `_scrapedAt` to track when each row was captured.
- **Pagination** — the actor chains continuation tokens automatically until `maxResults` is reached or YouTube returns no more pages. Very large `maxResults` values for narrow queries may end early simply because YouTube has no more results to give.
- **Why filters help** — `relevance` is broad and noisy for popular keywords. For trend monitoring, `today` or `this_week` give you only fresh uploads; for influencer discovery, `channel_only` strips out the videos; for view-driven research, `view_count` puts the biggest hits first.
- **Counts as text** — `viewCountText`, `subscriberCountText`, and `publishedTimeText` are returned as YouTube's localized strings (`"918,997,637 views"`, `"19.3M subscribers"`, `"3 days ago"`). Parse these client-side if you need numeric values.
- **No deduplication** — the actor does not deduplicate by `videoId` / `channelId` / `playlistId` across pages; downstream pipelines should dedupe if strict uniqueness is required.

# Actor input Schema

## `queries` (type: `array`):

List of YouTube search queries to run. Each query is processed independently and tagged in the output via the `_input` field so you can join results back to the input list.

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

Maximum number of results returned per query. The actor paginates automatically until this many items have been collected, or YouTube runs out of results. Set to 0 for unlimited.

## `filter` (type: `string`):

How results are filtered or sorted. Sort options: `relevance` (default YouTube ranking), `upload_date` (newest first), `view_count` (most viewed), `rating` (highest rated). Type filters: `video_only`, `channel_only`, `playlist_only`, `live` (currently live streams), `short` (videos under 4 minutes). Date filters: `today` (uploaded in the last 24h), `this_week` (uploaded in the last 7 days).

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

Apify Proxy settings. Datacenter proxies work well for YouTube search; switch to residential only if you see persistent rate-limit errors on very large runs.

## Actor input object example

```json
{
  "queries": [
    "linux tutorial",
    "python tutorial"
  ],
  "maxResults": 20,
  "filter": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "linux tutorial",
        "python tutorial"
    ],
    "maxResults": 20,
    "filter": "relevance"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/youtube-search-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 = {
    "queries": [
        "linux tutorial",
        "python tutorial",
    ],
    "maxResults": 20,
    "filter": "relevance",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/youtube-search-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 '{
  "queries": [
    "linux tutorial",
    "python tutorial"
  ],
  "maxResults": 20,
  "filter": "relevance"
}' |
apify call xtracto/youtube-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Search Scraper",
        "description": "Search YouTube videos, channels, and playlists. Filter by upload date, view count, length, live, shorts. Bulk-paginated.",
        "version": "1.0",
        "x-build-id": "TKk1hIEUPzVSVqtUL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~youtube-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-youtube-search-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/xtracto~youtube-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-youtube-search-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/xtracto~youtube-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-youtube-search-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of YouTube search queries to run. Each query is processed independently and tagged in the output via the `_input` field so you can join results back to the input list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results returned per query. The actor paginates automatically until this many items have been collected, or YouTube runs out of results. Set to 0 for unlimited.",
                        "default": 20
                    },
                    "filter": {
                        "title": "Filter / sort",
                        "enum": [
                            "relevance",
                            "upload_date",
                            "view_count",
                            "rating",
                            "video_only",
                            "channel_only",
                            "playlist_only",
                            "live",
                            "short",
                            "today",
                            "this_week"
                        ],
                        "type": "string",
                        "description": "How results are filtered or sorted. Sort options: `relevance` (default YouTube ranking), `upload_date` (newest first), `view_count` (most viewed), `rating` (highest rated). Type filters: `video_only`, `channel_only`, `playlist_only`, `live` (currently live streams), `short` (videos under 4 minutes). Date filters: `today` (uploaded in the last 24h), `this_week` (uploaded in the last 7 days).",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter proxies work well for YouTube search; switch to residential only if you see persistent rate-limit errors on very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
