# Youtube-Channel-Discovery (`skcho/youtube-channel-discovery-1`) Actor

Youtube-Channel-Discovery

- **URL**: https://apify.com/skcho/youtube-channel-discovery-1.md
- **Developed by:** [seungkyu cho](https://apify.com/skcho) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Channel Discovery & Enrichment

Discover YouTube channels through web-based search with advanced filtering options and optional YouTube Data API v3 enrichment for detailed channel statistics.

### 🎯 Features

- **Web-Based Discovery**: Scrapes YouTube search results using Playwright (no API quota needed for discovery)
- **Quota-Free Handle Resolution**: Resolves channel handles (like `@eatnlive` or non-ASCII Korean handles) using lightweight web requests, saving expensive YouTube Search API quota (100 units per query) and only consuming 1 unit per channel for enrichment.
- **Real-Time Output**: Pushes channel data to the Apify dataset in real-time (query-by-query) so you don't have to wait for the entire scraping run to complete.
- **Advanced Filters**: Filter results by upload date, content type, and sort order
- **API Enrichment**: Optional YouTube Data API v3 integration for subscriber counts, video stats, and metadata
- **Multiple Queries**: Process multiple search queries in a single run
- **Smart Deduplication**: Automatically removes duplicate channels across queries
- **High Capacity**: Up to 1000 channels per query
- **Error Resilience**: Query-level error isolation - one failed query won't stop others

### 📊 Use Cases

- **Influencer Research**: Find fitness, beauty, gaming, or tech channels by hashtags
- **Competitor Analysis**: Discover channels in your niche sorted by view count or relevance
- **Trend Monitoring**: Track newly uploaded content with time-based filters
- **Lead Generation**: Build lists of potential collaboration partners
- **Market Research**: Analyze channel distribution across topics

### 🚀 Quick Start

#### Basic Channel Search

```json
{
  "searchQueries": ["#fitness", "#yoga"],
  "filters": {
    "type": "channel",
    "sort": "relevance"
  },
  "maxResultsPerQuery": 50,
  "useYoutubeApi": true
}
````

#### Recent Video Creators

```json
{
  "searchQueries": ["home workout"],
  "filters": {
    "type": "video",
    "uploadDate": "week",
    "sort": "view_count"
  },
  "maxResultsPerQuery": 100,
  "useYoutubeApi": false
}
```

### 📥 Input Configuration

#### Required Fields

- **searchQueries** (array): List of search queries
  - Examples: `["#fitness", "yoga tutorial", "@channelname"]`
  - Min: 1, Max: 100 queries

#### Optional Fields

- **filters** (object): YouTube search filters
  - **uploadDate**: `"any"`, `"hour"`, `"today"`, `"week"`, `"month"`, `"year"`
  - **type**: `"video"`, `"channel"`, `"playlist"`
  - **sort**: `"relevance"`, `"upload_date"`, `"view_count"`, `"rating"`

- **maxResultsPerQuery** (integer): Maximum channels per query
  - Default: `100`
  - Range: `1` to `1000`

- **useYoutubeApi** (boolean): Enable API enrichment
  - Default: `true`
  - Set to `true` to get subscriber counts, video stats, and metadata
  - **Note**: Requires setting `YOUTUBE_API_KEY` in environment variables or providing `youtubeApiKey` in the input. If not provided, it will fallback to web-scraping only.

### 📤 Output Data

#### Basic Discovery (API enrichment disabled)

```json
{
  "channelId": "UCxxxxxxxxxxxx",
  "channelHandle": "@channelname",
  "channelUrl": "https://www.youtube.com/@channelname",
  "source": "video",
  "scrapedAt": "2026-01-13T02:00:22.489Z",
  "_searchQuery": "#fitness",
  "_timestamp": "2026-01-13T02:00:53.021Z"
}
```

#### With API Enrichment (useYoutubeApi: true)

```json
{
  "channelId": "UCxxxxxxxxxxxx",
  "channelHandle": "@channelname",
  "channelUrl": "https://www.youtube.com/@channelname",
  "title": "Fitness Channel Name",
  "description": "Welcome to our fitness journey...",
  "customUrl": "@channelname",
  "publishedAt": "2020-03-15T10:30:00Z",
  "thumbnails": {
    "default": { "url": "...", "width": 88, "height": 88 },
    "medium": { "url": "...", "width": 240, "height": 240 },
    "high": { "url": "...", "width": 800, "height": 800 }
  },
  "subscriberCount": 125000,
  "videoCount": 387,
  "viewCount": 15680000,
  "_enriched": true,
  "_enrichedAt": "2026-01-13T02:00:23.683Z",
  "_searchQuery": "#fitness",
  "_timestamp": "2026-01-13T02:00:53.021Z"
}
```

### 💡 YouTube API Enrichment

Enrich discovered channels with rich statistics by setting `useYoutubeApi: true`. To use API enrichment, either set the `YOUTUBE_API_KEY` environment variable in your Apify Actor settings, or provide the key via the `youtubeApiKey` input parameter.

When enabled, the Actor will retrieve:

- ✅ Subscriber counts
- ✅ Video counts
- ✅ Total view counts
- ✅ Channel descriptions
- ✅ Thumbnails
- ✅ Published dates

#### ⚡ Quota-Optimized Handle Resolution

Previously, converting scraped handles (e.g. `@channelname`) to channel IDs used the YouTube Search API, which consumes a massive **100 quota units** per call (exhausting default limits very quickly).

This Actor now uses **direct HTML parsing** via lightweight web requests to resolve channel IDs. This uses **0 API quota units** for handle resolution, meaning the API quota is only consumed for detail enrichment (**1 quota unit** per channel). This allows you to process up to 10,000 channels per day on a standard free API quota!

#### Performance Note

- **Without API enrichment**: ~20-50 channels per 10 seconds (fastest)
- **With API enrichment**: Adds a fast web-lookup and a 1-quota API call per channel (highly optimized, runs in concurrent batches)

### ⚙️ Advanced Configuration

#### High-Volume Collection

```json
{
  "searchQueries": ["fitness motivation"],
  "filters": {
    "type": "channel",
    "sort": "view_count"
  },
  "maxResultsPerQuery": 1000,
  "useYoutubeApi": true
}
```

**Note**: Large collections may take 5-10 minutes and consume more API quota.

#### Time-Sensitive Discovery

```json
{
  "searchQueries": ["#trending", "#shorts"],
  "filters": {
    "type": "video",
    "uploadDate": "today",
    "sort": "upload_date"
  },
  "maxResultsPerQuery": 30,
  "useYoutubeApi": true
}
```

**Use case**: Monitor newly uploaded content for real-time trending analysis.

#### Fast Discovery Without API

```json
{
  "searchQueries": ["workout", "exercise"],
  "filters": {
    "type": "channel"
  },
  "maxResultsPerQuery": 200,
  "useYoutubeApi": false
}
```

**Benefits**: Fastest execution, no API quota consumption, basic channel info only.

### 🎯 Filter Combinations

| Use Case | Type | Upload Date | Sort |
|----------|------|-------------|------|
| **Popular channels** | channel | any | view\_count |
| **New creators** | channel | week/month | upload\_date |
| **Trending videos** | video | today/week | view\_count |
| **Relevant content** | video/channel | any | relevance |
| **Highly rated** | video | any | rating |

### 📊 Performance

- **Discovery speed**: ~20-50 channels per 10 seconds
- **API enrichment**: ~50 channels per API call
- **Average run time**:
  - 50 channels without API: ~15 seconds
  - 50 channels with API: ~20 seconds
  - 500 channels with API: ~2 minutes
  - 1000 channels with API: ~5-10 minutes

### 🚨 Error Handling

#### Query-Level Isolation

If one query fails, others continue processing:

```json
{
  "summary": {
    "totalQueries": 3,
    "totalChannelsCollected": 150,
    "apiEnriched": 150
  },
  "results": [
    {
      "searchQuery": "#fitness",
      "channels": [...],
      "channelCount": 100
    },
    {
      "searchQuery": "#invalid",
      "channels": [],
      "error": {
        "message": "No results found",
        "code": "NO_RESULTS"
      }
    },
    {
      "searchQuery": "#yoga",
      "channels": [...],
      "channelCount": 50
    }
  ]
}
```

#### Common Issues

**No channels found**

- Try different search queries
- Remove or change filters
- Use `type: "video"` instead of `"channel"` (more results)

**API quota exhausted**

- Set `useYoutubeApi: false` temporarily
- Enrichment will automatically stop if quota is exhausted
- Actor will continue with basic data (no subscriber counts)

### 📖 Integration Examples

#### Node.js

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const input = {
  searchQueries: ['#fitness', '#workout'],
  filters: { type: 'channel', sort: 'view_count' },
  maxResultsPerQuery: 100,
  useYoutubeApi: true,  // API key is pre-configured!
};

const run = await client.actor('YOUR_ACTOR_ID').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Found ${items.length} channels`);
items.forEach(channel => {
  console.log(`${channel.title} - ${channel.subscriberCount} subscribers`);
});
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run_input = {
    'searchQueries': ['#fitness', '#workout'],
    'filters': {'type': 'channel', 'sort': 'view_count'},
    'maxResultsPerQuery': 100,
    'useYoutubeApi': True,  ## API key is pre-configured!
}

run = client.actor('YOUR_ACTOR_ID').call(run_input=run_input)
items = client.dataset(run['defaultDatasetId']).list_items().items

print(f"Found {len(items)} channels")
for channel in items:
    print(f"{channel['title']} - {channel['subscriberCount']} subscribers")
```

#### cURL

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["#fitness"],
    "filters": {"type": "channel", "sort": "view_count"},
    "maxResultsPerQuery": 100,
    "useYoutubeApi": true
  }'

## Note: YouTube API is pre-configured, no key needed!
```

### 🆘 Support

- **GitHub Issues**: [Report bugs or request features](https://github.com/skps2000/influix-official/issues)
- **Documentation**: See `DEPLOYMENT_GUIDE.md` and `TEST_SCENARIOS.md` in repository
- **Apify Forum**: [Get help from community](https://forum.apify.com/)

### 📝 Changelog

#### Version 1.1.0 (2026-06-07)

- ⚡ **Quota-Free Handle Resolution**: Implemented HTML-based channel ID resolution for handles to bypass expensive Search API limits (saving 100 quota units per channel).
- 🔄 **Real-Time Dataset Pushing**: Pushes discovered and enriched channels query-by-query in real-time so that results appear on the console immediately.
- 🔧 **Double-Encoding Bug Fix**: Fixed a bug where non-ASCII handles (like Korean) failed to resolve due to double URL encoding.
- 📂 **Apify Schema Alignment**: Standardized `.actor/input_schema.json` directory layout.

#### Version 1.0.0 (2026-01-13)

- ✅ Initial release
- ✅ Web-based channel discovery with Playwright
- ✅ YouTube Data API v3 enrichment
- ✅ Advanced search filters (upload date, type, sort)
- ✅ Multi-query support with deduplication
- ✅ Query-level error isolation
- ✅ Environment variable support for API keys
- ✅ Up to 1000 results per query

### 📄 License

MIT License - See repository for details

### 🙏 Credits

Built with:

- [Apify SDK](https://sdk.apify.com/) - Actor framework
- [Playwright](https://playwright.dev/) - Web automation
- [YouTube Data API v3](https://developers.google.com/youtube/v3) - Channel enrichment

***

**Ready to discover YouTube channels?** Click "Try it" and start exploring! 🚀

# Actor input Schema

## `searchQueries` (type: `array`):

List of search queries (hashtags, keywords, channel names). Example: #fitness, yoga tutorial

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

Type of content to search for

## `uploadDate` (type: `string`):

Filter by upload date

## `sortBy` (type: `string`):

Sort search results by specific criteria

## `maxResultsPerQuery` (type: `integer`):

Maximum channels to collect per query. Recommended: 50-100 for quick results, 500+ for comprehensive discovery.

## `useYoutubeApi` (type: `boolean`):

Get subscriber counts, video counts, and detailed metadata. YouTube API is pre-configured - just toggle this on!

## `youtubeApiKey` (type: `string`):

Optional: Provide your own YouTube Data API v3 key. If not provided, the Actor will attempt to use the YOUTUBE\_API\_KEY environment variable. If neither is available, it will fall back to web-scraping only.

## Actor input object example

```json
{
  "searchQueries": [
    "#fitness",
    "#yoga"
  ],
  "contentType": "channel",
  "uploadDate": "any",
  "sortBy": "relevance",
  "maxResultsPerQuery": 50,
  "useYoutubeApi": true
}
```

# Actor output Schema

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

All discovered channels in the default dataset.

## `summary` (type: `string`):

Summary object saved to key-value store under the OUTPUT key.

# 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 = {
    "searchQueries": [
        "#fitness",
        "#yoga"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("skcho/youtube-channel-discovery-1").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 = { "searchQueries": [
        "#fitness",
        "#yoga",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("skcho/youtube-channel-discovery-1").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 '{
  "searchQueries": [
    "#fitness",
    "#yoga"
  ]
}' |
apify call skcho/youtube-channel-discovery-1 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube-Channel-Discovery",
        "description": "Youtube-Channel-Discovery",
        "version": "0.0",
        "x-build-id": "HwYreiS7u92tFkVek"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skcho~youtube-channel-discovery-1/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skcho-youtube-channel-discovery-1",
                "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/skcho~youtube-channel-discovery-1/runs": {
            "post": {
                "operationId": "runs-sync-skcho-youtube-channel-discovery-1",
                "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/skcho~youtube-channel-discovery-1/run-sync": {
            "post": {
                "operationId": "run-sync-skcho-youtube-channel-discovery-1",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "List of search queries (hashtags, keywords, channel names). Example: #fitness, yoga tutorial",
                        "items": {
                            "type": "string"
                        }
                    },
                    "contentType": {
                        "title": "Content Type",
                        "enum": [
                            "video",
                            "channel",
                            "playlist"
                        ],
                        "type": "string",
                        "description": "Type of content to search for",
                        "default": "channel"
                    },
                    "uploadDate": {
                        "title": "Upload Date Filter",
                        "enum": [
                            "any",
                            "hour",
                            "today",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Filter by upload date",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "upload_date",
                            "view_count",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort search results by specific criteria",
                        "default": "relevance"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum channels to collect per query. Recommended: 50-100 for quick results, 500+ for comprehensive discovery.",
                        "default": 50
                    },
                    "useYoutubeApi": {
                        "title": "Enable API Enrichment",
                        "type": "boolean",
                        "description": "Get subscriber counts, video counts, and detailed metadata. YouTube API is pre-configured - just toggle this on!",
                        "default": true
                    },
                    "youtubeApiKey": {
                        "title": "YouTube API Key",
                        "type": "string",
                        "description": "Optional: Provide your own YouTube Data API v3 key. If not provided, the Actor will attempt to use the YOUTUBE_API_KEY environment variable. If neither is available, it will fall back to web-scraping only."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```