# MCP: YouTube Intel - AI Agents Transcript Metadata (`seibs.co/mcp-youtube-intelligence`) Actor

Model Context Protocol wrapper around youtube-intelligence. Exposes 5 AI-agent tools: fetch\_transcript, fetch\_metadata, bulk\_transcripts, search\_channel, find\_sponsored\_segments. Built for Claude, LangChain, LlamaIndex, Lindy. Pay per tool call + pass-through.

- **URL**: https://apify.com/seibs.co/mcp-youtube-intelligence.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** AI, Videos, Developer tools
- **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

## MCP: YouTube Intelligence (Apify Actor)

Model Context Protocol-style wrapper around the `youtube-intelligence` actor. Exposes 5 AI-agent-ready tools through a single Apify run, each one returning tight, predictable JSON suitable for direct injection into an LLM context window or tool-use loop.

Built for AI engineers wiring YouTube data into Claude, LangChain, LlamaIndex, Lindy, OpenAI Assistants, n8n, Make, and custom agent stacks.

### Why this exists

`youtube-intelligence` is powerful but is a batch-scraper at heart - one big input schema, one big dataset. Agents want small, semantically named tools with narrow contracts. This actor is the adapter:

- **One tool per run.** Pass `{tool: "fetch_transcript", args: {video_url: "..."}}` and get back exactly the shape that tool promises.
- **AI-friendly output.** Boolean `ok`, named `data` payload, named `error`, optional `count`. No deep-nested scraper artifacts to map around.
- **Cheap to invoke.** Flat `$0.003` per tool call on top of the pass-through cost of the underlying scraper run. Predictable line items for agent platforms.

### Available tools

Call with `tool: "list_tools"` (free, no charge) to get the live manifest with JSON Schema input definitions.

| Tool | Purpose | Required args |
|---|---|---|
| `fetch_transcript` | Full transcript text + timestamped segments | `video_url` |
| `fetch_metadata` | Title, channel, views, likes, chapters, hashtags, thumbnails | `video_url` |
| `bulk_transcripts` | Batched transcripts (up to 50 videos) | `video_urls` |
| `search_channel` | Recent videos from a channel by ID, `@handle`, or URL | `channel_id_or_handle` |
| `find_sponsored_segments` | Detect ad-read windows in the transcript with `{start, end, confidence}` | `video_url` |

All tools accept either a full YouTube URL or a bare 11-char video ID.

### Input

```json
{
  "tool": "fetch_transcript",
  "args": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "lang": "en"
  }
}
````

### Output (pushed to the default dataset)

```json
{
  "ok": true,
  "tool": "fetch_transcript",
  "data": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "video_id": "dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up",
    "channel": "Rick Astley",
    "language": "en",
    "is_generated": false,
    "segment_count": 87,
    "duration_seconds": 213.0,
    "text": "We're no strangers to love ...",
    "segments": [{"start": 0.0, "duration": 4.2, "text": "We're no strangers to love"}]
  }
}
```

On error: `{"ok": false, "tool": "...", "error": "...", "args": {...}}`.

### Pricing

- **$0.003** per MCP tool call (this actor).
- **Pass-through** for the underlying `youtube-intelligence` run (its own pay-per-event pricing: `$0.002` metadata, `$0.005` enriched, `$0.009` premium, plus optional comments / channel-data add-ons).

`list_tools` is free.

### Integration snippets

#### Claude (Anthropic SDK, tool use)

```python
import anthropic, json
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")
client = anthropic.Anthropic()

def call_yt_tool(name: str, args: dict) -> dict:
    run = apify.actor("Seibs.Co/mcp-youtube-intelligence").call(
        run_input={"tool": name, "args": args}
    )
    items = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
    return items[0] if items else {"ok": False, "error": "no items"}

tools = [{
    "name": "fetch_transcript",
    "description": "Fetch full transcript for a YouTube video.",
    "input_schema": {
        "type": "object",
        "properties": {"video_url": {"type": "string"}, "lang": {"type": "string"}},
        "required": ["video_url"],
    },
}]

msg = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Summarize https://youtu.be/dQw4w9WgXcQ"}],
)
## When msg.stop_reason == "tool_use", dispatch via call_yt_tool(...) and feed the result back.
```

#### LangChain

```python
from langchain.tools import StructuredTool
from pydantic import BaseModel, Field
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")
ACTOR_ID = "Seibs.Co/mcp-youtube-intelligence"

def _call(tool: str, args: dict) -> dict:
    run = apify.actor(ACTOR_ID).call(run_input={"tool": tool, "args": args})
    items = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
    return items[0] if items else {}

class TranscriptArgs(BaseModel):
    video_url: str = Field(..., description="YouTube URL or 11-char video ID")
    lang: str = Field("en", description="ISO 639-1 transcript language")

fetch_transcript = StructuredTool.from_function(
    name="fetch_transcript",
    description="Fetch full transcript for a YouTube video.",
    args_schema=TranscriptArgs,
    func=lambda video_url, lang="en": _call("fetch_transcript", {"video_url": video_url, "lang": lang}),
)
## Add fetch_transcript to your agent's tools list.
```

#### LlamaIndex

```python
from llama_index.core.tools import FunctionTool
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")

def fetch_metadata(video_url: str) -> dict:
    """Fetch YouTube video metadata (title, channel, views, likes, chapters)."""
    run = apify.actor("Seibs.Co/mcp-youtube-intelligence").call(
        run_input={"tool": "fetch_metadata", "args": {"video_url": video_url}}
    )
    return next(apify.dataset(run["defaultDatasetId"]).iterate_items(), {})

yt_tool = FunctionTool.from_defaults(fn=fetch_metadata)
## Pass yt_tool into AgentRunner / FunctionAgent / ReActAgent.
```

#### Lindy (no-code agent)

1. Add a new Action -> "Apify - Run Actor".
2. Actor: `Seibs.Co/mcp-youtube-intelligence`.
3. Input (JSON): `{"tool": "find_sponsored_segments", "args": {"video_url": "{{video_url}}"}}`.
4. Bind the dataset's first record to subsequent steps - use `data.sponsored_segments` for the ad-read windows.

#### n8n / Make

Use the Apify node, point it at this actor, and set Run Input to the same `{tool, args}` shape. Both platforms can read the default dataset directly from the run.

### Design notes

- **Single-tool dispatch pattern** mirrors how MCP servers expose `tools/list` + `tools/call`, but compresses both into the Apify run lifecycle so existing platform integrations work without custom MCP transport.
- **`list_tools` is the discovery surface.** Free, deterministic, returns valid JSON Schema for every tool. Use it to dynamically register tools in your agent at startup.
- **All output is flat-shaped.** Agents can `JSON.parse` the dataset record and read `data.title`, `data.segments`, etc. without unwrapping scraper internals.
- **`find_sponsored_segments` is a heuristic** (regex over transcript text + 60s decay window). It is fast, free of third-party deps, and tuned on common ad-read cadence. Expect false positives on creator-read promos; tune downstream with confidence threshold (0.5 base, +0.1 per additional trigger).

### Roadmap (deferred)

- Real MCP transport (stdio + SSE) via `usesStandbyMode` for clients that speak MCP natively.
- `summarize_video` tool that pipes transcript -> an LLM and returns a structured summary.
- `find_chapters_with_transcript` that fuses chapter metadata with their transcript spans.
- Sponsorship detection v2 using the SponsorBlock community dataset as a ground-truth overlay.

### Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click `Run` with your input fully configured.
2. Click the `Save as task` button at the top of the run page.
3. Name the task something memorable (e.g. `Saved YouTube query for agent - on-demand`).
4. Reload the task page and click `Start` anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

### Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click `Create new schedule`.
3. Pick your Task and set the cron expression. Common patterns:
   - Daily at 9am UTC: `0 9 * * *`
   - Weekly on Mondays at 9am: `0 9 * * 1`
   - Monthly on the 1st: `0 9 1 * *`
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks.

Schedules are unusual for MCP wrappers because AI agents invoke them on-demand. Use Tasks for saved configs but skip the cron schedule unless you have a specific batch-run use case.

### Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

- When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
- Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
- A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
- Optional: provide a Slack or email webhook URL in the `monitor_webhook_url` input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
- Cost: a single `scheduled_delta_run` event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

### Support

Built by Seibs.Co. Issues / requests: open a thread on the Apify Console actor page.

### Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/mcp-youtube-intelligence#reviews

# Actor input Schema

## `tool` (type: `string`):

MCP tool to invoke. Use 'list\_tools' to get the full manifest with schemas.

## `args` (type: `object`):

Arguments object matching the chosen tool's input\_schema. See README for examples.

## Actor input object example

```json
{
  "tool": "fetch_metadata",
  "args": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  }
}
```

# 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 = {
    "tool": "fetch_metadata",
    "args": {
        "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/mcp-youtube-intelligence").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 = {
    "tool": "fetch_metadata",
    "args": { "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/mcp-youtube-intelligence").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 '{
  "tool": "fetch_metadata",
  "args": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  }
}' |
apify call seibs.co/mcp-youtube-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MCP: YouTube Intel - AI Agents Transcript Metadata",
        "description": "Model Context Protocol wrapper around youtube-intelligence. Exposes 5 AI-agent tools: fetch_transcript, fetch_metadata, bulk_transcripts, search_channel, find_sponsored_segments. Built for Claude, LangChain, LlamaIndex, Lindy. Pay per tool call + pass-through.",
        "version": "0.1",
        "x-build-id": "WpAReaolhml2ybs4V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seibs.co~mcp-youtube-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seibs.co-mcp-youtube-intelligence",
                "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/seibs.co~mcp-youtube-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-seibs.co-mcp-youtube-intelligence",
                "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/seibs.co~mcp-youtube-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-seibs.co-mcp-youtube-intelligence",
                "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": [
                    "tool"
                ],
                "properties": {
                    "tool": {
                        "title": "Tool name",
                        "enum": [
                            "list_tools",
                            "fetch_transcript",
                            "fetch_metadata",
                            "bulk_transcripts",
                            "search_channel",
                            "find_sponsored_segments"
                        ],
                        "type": "string",
                        "description": "MCP tool to invoke. Use 'list_tools' to get the full manifest with schemas.",
                        "default": "list_tools"
                    },
                    "args": {
                        "title": "Tool arguments",
                        "type": "object",
                        "description": "Arguments object matching the chosen tool's input_schema. See README for examples.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```