# YouTube Hashtag Scraper (Videos & Shorts) (`lurkapi/youtube-hashtag-scraper`) Actor

Scrape videos and Shorts from YouTube hashtag pages. Get titles, channels, views, duration, thumbnails, and more.

- **URL**: https://apify.com/lurkapi/youtube-hashtag-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 video scrapeds

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

## YouTube Hashtag Scraper (Videos & Shorts)

Find every video and Short on any YouTube hashtag page. Type a hashtag like "cooking" or "fitness", hit Start, and get structured data on every result. No coding required.

### 🎬 What it does

Pick any YouTube hashtag, and this tool will pull every video and Short listed under it. For each one, you get the title, view count, channel name, thumbnail, video length, and a direct link to watch it.

You can:

1. **Scrape multiple hashtags at once** (up to 50 per run)
2. **Choose between Videos, Shorts, or both**
3. **Collect up to 500 results per hashtag**
4. **Filter by keywords in the title** (e.g. only videos mentioning "beginner")
5. **Filter by date** (e.g. only videos from the last 7 days)
6. **Export results** as JSON, CSV, or Excel from the Output tab

Great for marketers, content creators, researchers, or anyone who wants to track what's trending under a specific hashtag.

### 📋 How to use it

#### Step 1: Enter your hashtags

Type one or more hashtags. Any of these formats work:
- `cooking`
- `#cooking`
- `https://www.youtube.com/hashtag/cooking`

All three give you the same results.

#### Step 2: Pick your options

- **Max Videos Per Hashtag**: How many results you want per hashtag. Default is 50, maximum is 500.
- **Content Type**: Get all results, only regular videos, or only Shorts.
- **Title Filter**: Only keep videos whose title contains a specific keyword. For example, if you are scraping the hashtag "cooking" but only want results about pasta, type `pasta` in this field. You can also type multiple keywords separated by commas (e.g. `pasta, sushi, salad`) and the tool will keep any video that matches at least one of them. Leave this field empty to keep all videos. This filter is free and does not affect your bill.
- **Published Within (Days)**: Only keep videos posted in the last N days. For example, type `7` to only get videos from the past week, or `30` for the past month. Leave empty to get all results regardless of when they were posted.
- **Concurrency**: How many hashtags to process at the same time. Default is 3, maximum is 10. Higher values finish faster.

#### Step 3: Click Start

Results show up in real time in the Output tab. You do not have to wait for the full run to finish. When you are done, export your results from the Output tab.

#### For developers

You can also call this tool through the Apify API:

```json
{
    "hashtags": ["cooking", "#fitness", "https://www.youtube.com/hashtag/music"],
    "maxVideosPerHashtag": 100,
    "contentType": "all",
    "concurrency": 3
}
````

### 📊 What you get

#### Every result includes

| Field | What it means |
|-------|---------------|
| status | "Success" or a message explaining what went wrong |
| hashtag | Which hashtag this video came from |
| videoId | The YouTube video ID |
| videoUrl | A direct link to watch the video |
| title | The video title |
| channelName | The channel that uploaded it |
| channelUrl | A link to the channel |
| isVerified | Whether the channel has a blue checkmark |
| thumbnailUrl | A link to the video thumbnail image |
| viewCount | Total views as a number (e.g. 1200000) |
| viewCountText | Views as shown on YouTube (e.g. "1.2M views") |
| publishedText | When it was posted (e.g. "3 days ago") |
| duration | Video length (e.g. "12:34") |
| contentType | Either "video" or "short" |

#### With the Video Stats add-on

Turn on "Include Video Stats" to also get:

| Field | What it means |
|-------|---------------|
| likeCount | Number of likes |
| commentCount | Number of comments |
| description | The full video description |
| category | YouTube category (e.g. "Education", "Music") |
| tags | Keywords the creator added to the video |
| publishedDate | Exact publish date (e.g. "Feb 25, 2021") |
| subscriberCount | How many subscribers the channel has |

#### With the Language Detection add-on

Turn on "Detect Language" to also get:

| Field | What it means |
|-------|---------------|
| detectedLanguage | The spoken language (e.g. "en" for English, "ko" for Korean, "es" for Spanish) |

#### With the Channel Analytics add-on

Turn on "Include Channel Analytics" to also get:

| Field | What it means |
|-------|---------------|
| channelDescription | The channel's About section |
| channelCountry | Where the channel is based (e.g. "United States") |
| channelSubscriberCount | Total subscribers |
| channelVideoCount | Total videos on the channel |
| channelViewCount | Total views across all videos |
| channelJoinedDate | When the channel was created (e.g. "Sep 10, 2018") |

#### The status field

Every result has a `status` field. If everything worked, it says "Success". If something went wrong, it tells you exactly what happened and what to do about it.

### 🌐 Proxy settings

Proxies help the tool access YouTube without getting blocked. The default setting works for most people.

- **Automatic (default)**: The best option for most users. Just leave it as is.
- **Residential**: Try this if you keep getting empty results or errors. It is slower but more reliable.
- **Own proxies**: Use your own proxy URLs if you have them.
- **No proxy**: Not recommended. You may get blocked by YouTube.

### 💰 Pricing

You only pay for results that are successfully collected. Failed or filtered results are free.

**Base price:** $1.50 per 1,000 videos

**Optional add-ons (only charged when enabled):**

| Add-on | Cost per 1,000 videos | What you get |
|--------|----------------------|-------------|
| Video Stats | $0.25 | Likes, comments, description, category, tags, exact date |
| Language Detection | $0.10 | Spoken language of the video |
| Channel Analytics | $0.25 | Subscribers, total videos, views, country, join date |

**How much will it cost?**

| What you are doing | Cost |
|-------------------|------|
| 100 videos, no add-ons | $0.15 |
| 500 videos, no add-ons | $0.75 |
| 500 videos with all add-ons | $1.05 |
| 1,000 videos with all add-ons | $2.10 |

### 💡 Good to know

- **Shorts have less data than regular videos.** YouTube does not provide channel name, published date, or duration for Shorts in hashtag feeds. This is a YouTube limitation, not a bug in this tool.
- **Use filters to save money.** If you only need Shorts, pick "Shorts only" so you do not pay for videos you do not need. Same with the title filter and date filter.
- **Same video, different hashtags.** If a video appears under two hashtags you are scraping, it will show up twice in your results (once for each hashtag).
- **Some hashtags have more results than others.** Popular hashtags like "music" can return hundreds of results. Niche hashtags might only have a few.
- **Your data is saved in your Apify storage.** How long it stays depends on your Apify plan.

### ❓ FAQ

**I got zero results. What happened?**
The hashtag probably does not exist on YouTube, or there are no public videos under it. Try a popular hashtag like "music" or "cooking" to make sure everything is working.

**Why are some fields blank for Shorts?**
YouTube does not include all the same information for Shorts as it does for regular videos. Channel name, published date, and video length are often missing for Shorts. There is nothing we can do about this.

**Which proxy setting should I pick?**
Leave it on Automatic. That works for most people. If you are getting a lot of errors or empty results, switch to Residential.

**Can I get more than 500 videos from one hashtag?**
No. YouTube only shows a limited number of videos per hashtag page. 500 is the maximum this tool will try to collect.

**How long is my data kept?**
Your results are stored in your Apify account. How long they are kept depends on your subscription plan.

**Can I call this tool from my own app or script?**
Yes. You can use the Apify API or the official client libraries for JavaScript and Python. Check the API tab for details.

**What happens if YouTube blocks me?**
The tool automatically switches to a different connection when it detects a block. If that keeps happening, try running with Residential proxies turned on.

### 🔗 Other tools you might like

- [YouTube Comments Scraper](https://apify.com/lurkapi/youtube-comments-scraper) - Pull comments and replies from any YouTube video, with language detection.

### ⚖️ Disclaimer

This tool is built for personal, research, and educational use. You are responsible for following YouTube's Terms of Service and any laws that apply in your country. The developer is not responsible for how you use this tool. Results depend on what YouTube makes available at the time of your run.

**Keywords:** youtube hashtag scraper, youtube hashtag videos, youtube shorts scraper, scrape youtube hashtag, youtube video metadata, youtube hashtag data, youtube trending hashtags

# Actor input Schema

## `hashtags` (type: `array`):

YouTube hashtags to scrape. Accepts: bare name (coding), with # prefix (#coding), or full URL (youtube.com/hashtag/coding).

## `maxVideosPerHashtag` (type: `integer`):

Maximum number of videos to scrape per hashtag. Default 50, max 500.

## `contentType` (type: `string`):

Filter by content type: all videos and Shorts, only regular videos, or only Shorts.

## `titleFilter` (type: `string`):

Only keep videos whose title contains a specific keyword. For example, type 'pasta' to only get cooking videos about pasta. You can type multiple keywords separated by commas (e.g. 'pasta, sushi, salad'). Leave empty to keep all videos. This filter is free.

## `publishedWithinDays` (type: `integer`):

Only include videos published within the last N days. Leave empty or 0 to include all videos regardless of age. Note: date filtering relies on YouTube's approximate relative timestamps (e.g. '3 days ago'), so results may not be perfectly precise.

## `includeVideoStats` (type: `boolean`):

Fetch stats for each video: likes, comment count, full description, category, tags, and exact publish date. This is a paid add-on ($0.25 per 1,000 videos) and makes the scraper slower since it fetches each video individually.

## `detectLanguage` (type: `boolean`):

Detect the spoken language of each video using YouTube's caption data. Adds a detectedLanguage field (e.g. 'en', 'ko', 'es'). Only charged when language is successfully detected ($0.10 per 1,000 videos).

## `includeChannelAnalytics` (type: `boolean`):

Fetch analytics for each video's channel: subscriber count, total videos, total views, channel description, country, and join date. Results are cached per channel so you only pay once per unique channel. This is a paid add-on ($0.25 per 1,000 videos).

## `concurrency` (type: `integer`):

Number of hashtags to process in parallel (max 10). Higher values are faster but use more memory.

## `proxyConfig` (type: `object`):

Select proxies for accessing YouTube.

## Actor input object example

```json
{
  "hashtags": [
    "cooking"
  ],
  "maxVideosPerHashtag": 50,
  "contentType": "all",
  "includeVideoStats": false,
  "detectLanguage": false,
  "includeChannelAnalytics": false,
  "concurrency": 3,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `videos` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "hashtags": [
        "cooking"
    ],
    "contentType": "all",
    "includeVideoStats": false,
    "detectLanguage": false,
    "includeChannelAnalytics": false,
    "concurrency": 3,
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/youtube-hashtag-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 = {
    "hashtags": ["cooking"],
    "contentType": "all",
    "includeVideoStats": False,
    "detectLanguage": False,
    "includeChannelAnalytics": False,
    "concurrency": 3,
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/youtube-hashtag-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 '{
  "hashtags": [
    "cooking"
  ],
  "contentType": "all",
  "includeVideoStats": false,
  "detectLanguage": false,
  "includeChannelAnalytics": false,
  "concurrency": 3,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-hashtag-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Hashtag Scraper (Videos & Shorts)",
        "description": "Scrape videos and Shorts from YouTube hashtag pages. Get titles, channels, views, duration, thumbnails, and more.",
        "version": "0.0",
        "x-build-id": "Wcrkycdj4yNz2bjEk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-hashtag-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-hashtag-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/lurkapi~youtube-hashtag-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-hashtag-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/lurkapi~youtube-hashtag-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-hashtag-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": [
                    "hashtags"
                ],
                "properties": {
                    "hashtags": {
                        "title": "Hashtags",
                        "maxItems": 50,
                        "type": "array",
                        "description": "YouTube hashtags to scrape. Accepts: bare name (coding), with # prefix (#coding), or full URL (youtube.com/hashtag/coding).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerHashtag": {
                        "title": "Max Videos Per Hashtag",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of videos to scrape per hashtag. Default 50, max 500.",
                        "default": 50
                    },
                    "contentType": {
                        "title": "Content Type",
                        "enum": [
                            "all",
                            "videos",
                            "shorts"
                        ],
                        "type": "string",
                        "description": "Filter by content type: all videos and Shorts, only regular videos, or only Shorts.",
                        "default": "all"
                    },
                    "titleFilter": {
                        "title": "Title Filter",
                        "type": "string",
                        "description": "Only keep videos whose title contains a specific keyword. For example, type 'pasta' to only get cooking videos about pasta. You can type multiple keywords separated by commas (e.g. 'pasta, sushi, salad'). Leave empty to keep all videos. This filter is free."
                    },
                    "publishedWithinDays": {
                        "title": "Published Within (Days)",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include videos published within the last N days. Leave empty or 0 to include all videos regardless of age. Note: date filtering relies on YouTube's approximate relative timestamps (e.g. '3 days ago'), so results may not be perfectly precise."
                    },
                    "includeVideoStats": {
                        "title": "Include Video Stats",
                        "type": "boolean",
                        "description": "Fetch stats for each video: likes, comment count, full description, category, tags, and exact publish date. This is a paid add-on ($0.25 per 1,000 videos) and makes the scraper slower since it fetches each video individually.",
                        "default": false
                    },
                    "detectLanguage": {
                        "title": "Detect Language",
                        "type": "boolean",
                        "description": "Detect the spoken language of each video using YouTube's caption data. Adds a detectedLanguage field (e.g. 'en', 'ko', 'es'). Only charged when language is successfully detected ($0.10 per 1,000 videos).",
                        "default": false
                    },
                    "includeChannelAnalytics": {
                        "title": "Include Channel Analytics",
                        "type": "boolean",
                        "description": "Fetch analytics for each video's channel: subscriber count, total videos, total views, channel description, country, and join date. Results are cached per channel so you only pay once per unique channel. This is a paid add-on ($0.25 per 1,000 videos).",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of hashtags to process in parallel (max 10). Higher values are faster but use more memory.",
                        "default": 3
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies for accessing YouTube.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
