# YouTube Channel Contact Scraper — Email, Website & Socials (`haketa/youtube-contact-scraper`) Actor

Find YouTube creators and get their contact details in bulk. Search by keyword or paste channel URLs and get channel name, subscribers, views, country, business email, website and all social links. Fast, keyless YouTube influencer & creator lead generation.

- **URL**: https://apify.com/haketa/youtube-contact-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Channel Contact Scraper — Email, Website & Social Links

Find YouTube creators and pull their **contact details in bulk.** Search by keyword or niche, or paste a list of channels, and get for each one: **channel name, subscribers, views, country, join date, business email, website and every social link** — Instagram, TikTok, Twitter/X, Facebook, LinkedIn, Discord and more.

Built for **influencer marketing, creator outreach and lead generation.** Fast, keyless, and ready to export to your CRM or outreach tool.

---

### Why this Actor?

Finding creators is easy; getting their **contact details at scale** is not. YouTube shows a channel's business email behind a click and scatters its links across the page. This Actor turns a keyword or a channel list into a clean, structured contact sheet:

- **Discover** channels by keyword/niche — one keyword returns dozens to hundreds of matching creators.
- **Enrich** each channel with subscribers, views, country and join date.
- **Extract** the business email, website and all social profiles — the exact fields you need to reach out.

It's perfect for building **influencer shortlists, partnership pipelines and creator databases** without copying and pasting from hundreds of channel pages.

---

### What you can do with it

- **Influencer marketing** — build a shortlist of creators in a niche with their size, country and email in one table.
- **Brand partnerships & sponsorships** — reach the business/partnership inbox directly instead of a contact form.
- **Agency lead generation** — assemble creator lead lists to pitch your services to.
- **Competitor & market research** — map the creators in a topic, their reach and their other social channels.
- **Multi‑platform outreach** — get each creator's Instagram/TikTok/Twitter so you can reach them where they respond.
- **CRM enrichment** — turn a list of channel URLs into a full contact record.

---

### What you get — output fields

One record per channel:

| Field | Description |
| --- | --- |
| `channelName` | Channel name |
| `handle` | `@handle` |
| `channelUrl` | Canonical channel URL |
| `channelId` | YouTube channel ID |
| `subscribers` | Subscriber count as a number (e.g. `21100000`) |
| `subscribersText` | Subscriber count as shown (e.g. `21.1M subscribers`) |
| `videoCount` | Number of videos |
| `viewCount` | Total channel views |
| `country` | Channel country |
| `joinedDate` | When the channel was created |
| `email` | Business / contact email |
| `website` | Linked website |
| `socialLinks` | All social‑media links (Instagram, TikTok, X, Facebook, LinkedIn, Discord…) |
| `allLinks` | Every external link on the channel |
| `description` | Channel description |
| `aboutUrl` | The about page that was read |
| `error` | Populated only if the channel couldn't be read |
| `scrapedAt` | ISO timestamp |

Email is present for a large share of creator/business channels; when a channel doesn't publish one on YouTube, the Actor can look on its linked website (see `enrichFromWebsite`).

---

### Example output

```json
{
  "channelName": "Marques Brownlee",
  "handle": "@mkbhd",
  "channelUrl": "http://www.youtube.com/@mkbhd",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "subscribers": "21100000",
  "subscribersText": "21.1M subscribers",
  "videoCount": "1800",
  "viewCount": "5472040173",
  "country": "United States",
  "joinedDate": "Mar 21, 2008",
  "email": "business@MKBHD.com",
  "website": "",
  "socialLinks": "https://twitter.com/MKBHD, https://instagram.com/MKBHD, https://discord.gg/MKBHD",
  "description": "MKBHD: Quality Tech Videos...",
  "scrapedAt": "2026-07-09T13:00:00.000Z"
}
````

***

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchKeywords` | array | — | Keywords/niches to discover channels by. |
| `channelUrls` | array | — | Specific channels (URLs, `@handles` or channel IDs). |
| `maxChannelsPerKeyword` | integer | `40` | How many channels to collect per keyword. |
| `minSubscribers` | integer | `0` | Keep only channels with at least this many subscribers. |
| `enrichFromWebsite` | boolean | `true` | If no email on YouTube, look on the channel's website. |
| `maxConcurrency` | integer | `10` | Channels processed in parallel. |
| `proxyConfiguration` | object | off | Apify Proxy (enable for very large runs). |

Provide `searchKeywords`, `channelUrls`, or both.

#### Discover creators by niche

```json
{
  "searchKeywords": ["tech reviewer", "home workout", "vegan recipes"],
  "maxChannelsPerKeyword": 50,
  "minSubscribers": 10000
}
```

#### Scrape specific channels

```json
{
  "channelUrls": ["@mkbhd", "https://youtube.com/@LinusTechTips", "@MrBeast"]
}
```

#### Both together

```json
{
  "searchKeywords": ["drone review"],
  "channelUrls": ["@mkbhd"],
  "maxChannelsPerKeyword": 30
}
```

***

### Use cases in detail

#### 1. Build an influencer shortlist

Search your niche (e.g. `"skincare routine"`), set `minSubscribers` to your target size, and get a table of creators with subscribers, country and email — ready to filter and pitch.

#### 2. Reach the right inbox

`email` is the creator's public business/contact address, so your outreach lands in the inbox they actually use for partnerships — not a generic form.

#### 3. Multi‑channel outreach

`socialLinks` gives you each creator's Instagram, TikTok, X and more, so if email goes unanswered you can follow up where they're most active.

#### 4. Size and vet creators

`subscribers`, `viewCount` and `videoCount` let you gauge reach and consistency before you invest time reaching out.

#### 5. Map a niche

Run several keywords for a topic and you get a map of the creators in that space, their audiences and their links — great for competitive and market research.

#### 6. Keep a creator database fresh

Schedule the Actor on your keyword set to keep discovering new channels and refreshing contact details over time.

***

### How to use it

1. Click **Try for free**.
2. Enter **search keywords**, **channel URLs**, or both.
3. (Optional) Set `minSubscribers`, `maxChannelsPerKeyword` or concurrency.
4. Click **Start**.
5. Export as **JSON, CSV, Excel** or **HTML table**, or via the Apify API.

***

### Calling from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchKeywords": ["tech reviewer"], "maxChannelsPerKeyword": 50, "minSubscribers": 10000 }'
```

Fetch the results (JSON or CSV):

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv"
```

***

### Tips for the best results

- **Use specific keywords.** `"budget mechanical keyboards"` finds more relevant creators than `"tech"`.
- **Run many keywords** to cover a niche broadly — each one brings a fresh set of channels.
- **Set `minSubscribers`** to filter out tiny channels and focus on creators at your target size.
- **Keep `enrichFromWebsite` on** to recover emails for channels that don't show one on YouTube.
- **Filter `email` is not empty** in your export to get an instantly actionable outreach list.
- **Raise concurrency and enable proxy** for very large keyword sets.

***

### Frequently asked questions

**How does it discover channels from a keyword?**
It searches YouTube for channels matching the keyword and collects them up to your limit, then reads each channel's about page for the details.

**Where does the email come from?**
From the channel's own public contact/business email and description. If none is shown and `enrichFromWebsite` is on, it checks the channel's linked website. It never logs in or contacts anyone.

**Why is `email` or `website` sometimes empty?**
Not every creator publishes a business email or a website. Social links and channel metrics are still returned.

**Can I pass @handles or channel IDs?**
Yes — full URLs, `@handles` and `UC…` channel IDs all work.

**How many channels can it handle?**
From a few to many thousands. Use multiple keywords and/or a large channel list; raise concurrency and enable proxy for big runs.

**In which format can I export?**
JSON, CSV, Excel, HTML table, or via the Apify API.

**Do I need an API key?**
No. Just enter keywords or channels and run.

***

### Responsible use

Contact details returned by this Actor are ones creators have chosen to publish, but they are still personal data. You are responsible for using them lawfully:

- Comply with anti‑spam and marketing laws (e.g. GDPR and ePrivacy in the EU, CAN‑SPAM in the US) when contacting creators, and honour opt‑outs.
- Only use the data for legitimate business outreach and research.
- Respect each creator's and platform's terms.

This Actor is provided for lawful marketing, partnership and research purposes. It does not provide legal advice.

***

### Support

Want extra fields (e.g. recent‑video stats, engagement estimates) or discovery from video URLs? Open an issue from the Actor's page and describe what you need.

# Actor input Schema

## `topicPreset` (type: `array`):

Pick one or more popular creator niches and instantly get matching channels with their contact details. No typing needed — just tick the niches you want. Leave everything empty to get a ready-made mix of top niches.

## `searchKeywords` (type: `array`):

Type your own niches or topics to find channels by (e.g. "vegan recipes", "home workout", "drone reviews"). Each keyword returns matching channels up to the limit below. Combine freely with the niches picker above.

## `channelUrls` (type: `array`):

Already know which channels you want? Add them here as full URLs, @handles or channel IDs (e.g. "@mkbhd", "https://youtube.com/@LinusTechTips"). Optional — most users just pick niches or type keywords above.

## `maxChannels` (type: `integer`):

Overall cap on how many channels to return across all niches and keywords. Keeps runs fast and affordable. 0 = no overall cap.

## `maxChannelsPerKeyword` (type: `integer`):

How many channels to collect for each niche or keyword.

## `minSubscribers` (type: `integer`):

Only keep channels with at least this many subscribers, so you can focus on bigger creators. 0 = keep all.

## `enrichFromWebsite` (type: `boolean`):

If no email is on the channel page, open the channel's linked website and look for a contact email there — great for higher email coverage.

## `maxConcurrency` (type: `integer`):

How many channels to process in parallel. Higher is faster.

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

Apify Proxy. Off by default; enable (and raise for large runs) if you need extra reliability on very big jobs.

## Actor input object example

```json
{
  "searchKeywords": [
    "tech reviewer"
  ],
  "maxChannels": 100,
  "maxChannelsPerKeyword": 20,
  "minSubscribers": 0,
  "enrichFromWebsite": true,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `channelName` (type: `string`):

Channel name

## `handle` (type: `string`):

@handle

## `channelUrl` (type: `string`):

Canonical channel URL

## `channelId` (type: `string`):

YouTube channel ID

## `subscribers` (type: `string`):

Subscriber count (number)

## `subscribersText` (type: `string`):

Subscriber count as shown

## `videoCount` (type: `string`):

Number of videos

## `viewCount` (type: `string`):

Total channel views

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

Channel country

## `joinedDate` (type: `string`):

Join date

## `email` (type: `string`):

Business/contact email

## `website` (type: `string`):

Linked website

## `socialLinks` (type: `string`):

Social media links

## `allLinks` (type: `string`):

All external links

## `description` (type: `string`):

Channel description

## `aboutUrl` (type: `string`):

About page scraped

## `error` (type: `string`):

Error, if any

## `scrapedAt` (type: `string`):

Timestamp

# 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 = {
    "searchKeywords": [
        "tech reviewer"
    ],
    "maxChannels": 100,
    "maxChannelsPerKeyword": 20,
    "maxConcurrency": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/youtube-contact-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 = {
    "searchKeywords": ["tech reviewer"],
    "maxChannels": 100,
    "maxChannelsPerKeyword": 20,
    "maxConcurrency": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/youtube-contact-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 '{
  "searchKeywords": [
    "tech reviewer"
  ],
  "maxChannels": 100,
  "maxChannelsPerKeyword": 20,
  "maxConcurrency": 10
}' |
apify call haketa/youtube-contact-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Contact Scraper — Email, Website & Socials",
        "description": "Find YouTube creators and get their contact details in bulk. Search by keyword or paste channel URLs and get channel name, subscribers, views, country, business email, website and all social links. Fast, keyless YouTube influencer & creator lead generation.",
        "version": "0.1",
        "x-build-id": "AtyZWaaiaM6dyHX4j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~youtube-contact-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-youtube-contact-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/haketa~youtube-contact-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-youtube-contact-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/haketa~youtube-contact-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-youtube-contact-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",
                "properties": {
                    "topicPreset": {
                        "title": "Popular niches (pick to get started)",
                        "type": "array",
                        "description": "Pick one or more popular creator niches and instantly get matching channels with their contact details. No typing needed — just tick the niches you want. Leave everything empty to get a ready-made mix of top niches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tech reviewer",
                                "gaming",
                                "beauty and makeup",
                                "fitness and workout",
                                "cooking and recipes",
                                "travel vlogger",
                                "personal finance",
                                "business and marketing",
                                "music",
                                "education and tutorials",
                                "fashion and style",
                                "health and wellness",
                                "podcast",
                                "real estate",
                                "photography",
                                "home and DIY",
                                "automotive and cars",
                                "family and parenting",
                                "comedy",
                                "science and technology"
                            ],
                            "enumTitles": [
                                "Tech reviewers",
                                "Gaming",
                                "Beauty & makeup",
                                "Fitness & workout",
                                "Cooking & recipes",
                                "Travel vloggers",
                                "Personal finance",
                                "Business & marketing",
                                "Music",
                                "Education & tutorials",
                                "Fashion & style",
                                "Health & wellness",
                                "Podcasters",
                                "Real estate",
                                "Photography",
                                "Home & DIY",
                                "Automotive & cars",
                                "Family & parenting",
                                "Comedy",
                                "Science & tech"
                            ]
                        }
                    },
                    "searchKeywords": {
                        "title": "Search keywords (optional)",
                        "type": "array",
                        "description": "Type your own niches or topics to find channels by (e.g. \"vegan recipes\", \"home workout\", \"drone reviews\"). Each keyword returns matching channels up to the limit below. Combine freely with the niches picker above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Specific channels (advanced, optional)",
                        "type": "array",
                        "description": "Already know which channels you want? Add them here as full URLs, @handles or channel IDs (e.g. \"@mkbhd\", \"https://youtube.com/@LinusTechTips\"). Optional — most users just pick niches or type keywords above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxChannels": {
                        "title": "Max channels (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Overall cap on how many channels to return across all niches and keywords. Keeps runs fast and affordable. 0 = no overall cap.",
                        "default": 0
                    },
                    "maxChannelsPerKeyword": {
                        "title": "Max channels per keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many channels to collect for each niche or keyword.",
                        "default": 40
                    },
                    "minSubscribers": {
                        "title": "Minimum subscribers",
                        "type": "integer",
                        "description": "Only keep channels with at least this many subscribers, so you can focus on bigger creators. 0 = keep all.",
                        "default": 0
                    },
                    "enrichFromWebsite": {
                        "title": "Find email on channel website",
                        "type": "boolean",
                        "description": "If no email is on the channel page, open the channel's linked website and look for a contact email there — great for higher email coverage.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many channels to process in parallel. Higher is faster.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy. Off by default; enable (and raise for large runs) if you need extra reliability on very big jobs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
