# YouTube Video Info Extractor — Metadata & Captions API (`perryay/youtube-video-info-extractor`) Actor Extract YouTube video metadata — title, channel, publish date, duration, view/like/comment counts, tags, thumbnail, transcripts/captions. No API key required — powered by yt-dlp. Supports batch processing of up to 50 videos per run. - **URL**: https://apify.com/perryay/youtube-video-info-extractor.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Social media, Developer tools - **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.02 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Video Info Extractor — Metadata & Transcripts ### YouTube Video Info Extractor — Metadata & Transcripts **Extract detailed metadata from YouTube videos — title, description, channel info, publish date, duration, view/like/comment counts, tags, thumbnail URL, and optional transcripts/subtitles.** Whether you're building a content analysis pipeline, creating a video archive, or researching YouTube trends, this actor extracts everything you need in a single call. --- ### What does it do? This actor takes one or more YouTube video URLs and extracts comprehensive metadata from each one using yt-dlp — the most reliable YouTube data extraction library. For each video you get the title, channel information, publishing date, duration (ISO 8601), engagement metrics (views, likes, comments), tags, thumbnail URL, and optionally the full transcript or subtitles. The actor handles all the edge cases: private videos, deleted content, age-restricted uploads, and region-blocked videos are caught gracefully and reported without halting the batch. Results are streamed to the dataset as each video completes, so you can start consuming data before the full batch finishes. Concurrent processing with a configurable semaphore (max 2 simultaneous extractions) balances speed against YouTube's rate limits, and the actor charges one `video-extract` event per video processed. ### Features 1. **Full metadata extraction** — Title, channel name, channel URL, published date, ISO 8601 duration, view count, like count, comment count, tags, and thumbnail URL. 2. **Optional transcript support** — Fetch video transcripts/subtitles as plain text when `includeTranscript` is enabled. Automatically picks English subtitles (manual or auto-generated) with fallback to any available language. 3. **Batch processing** — Submit multiple YouTube URLs in a single run. Process up to 50 videos at once (configurable via `maxResults`). 4. **Concurrent extraction** — Up to 2 simultaneous yt-dlp extractions via asyncio semaphore, balancing throughput against rate limits. 5. **Graceful error handling** — Private videos, deleted content, age-restricted uploads, region blocks, and copyright takedowns are reported per-video without affecting other results in the batch. 6. **ISO 8601 durations** — Video duration is returned in standard ISO 8601 format (e.g., `PT5M30S`, `PT1H2M15S`) for easy parsing. 7. **ISO 8601 timestamps** — Publish dates are returned in ISO 8601 format (`YYYY-MM-DDTHH:MM:SSZ`). ### Why use this? | Problem | Solution | |---------|----------| | You need to analyze a large set of YouTube videos programmatically | Submit all URLs in one batch and get structured metadata for every video | | You want to build a searchable video archive | Extract tags, descriptions, and transcripts for full-text indexing | | You're researching content trends or channel performance | Get view counts, like counts, and comment counts for every video | | You need clean transcript text for NLP or summarization | Enable transcript extraction once and get plain-text output | | You're migrating or backing up YouTube content metadata | Batch-extract all metadata in a structured, machine-readable format | | You want to know why a video failed extraction | Every error is classified (private, deleted, age-restricted, etc.) per video | ### Who is it for? | Persona | What they use it for | |---------|---------------------| | Content Analyst | Extracting metadata and transcripts from video playlists for trend analysis | | Data Engineer | Building ETL pipelines that ingest YouTube metadata into data warehouses | | Researcher | Collecting video metadata and transcripts for academic NLP or social science research | | Creator / Marketer | Auditing a competitor's video library for SEO tags, engagement stats, and content patterns | | Archive Curator | Cataloguing video metadata before taking down or migrating content | | Developer | Building applications that need programmatic access to YouTube video details | ### Input Parameters | Field | Type | Default | Description | |-------|------|---------|-------------| | `urls` | array | — | Array of YouTube video URLs to process (e.g., `["https://www.youtube.com/watch?v=..."]`) | | `includeTranscript` | boolean | `false` | Whether to fetch and include video transcript/subtitles (English preferred, auto-generated or manual) | | `maxResults` | integer | `10` | Maximum number of videos to process. Range: 1-50. | #### Example Input JSON ```json { "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "includeTranscript": false, "maxResults": 10 } ```` #### Example Input with Transcript ```json { "urls": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "https://www.youtube.com/watch?v=jNQXAC9IVRw" ], "includeTranscript": true, "maxResults": 5 } ``` ### Output Format | Field | Type | Description | |-------|------|-------------| | `url` | string | The YouTube video URL that was processed | | `title` | string or null | Title of the YouTube video | | `channel` | string or null | Name of the YouTube channel that published the video | | `channelUrl` | string or null | URL to the YouTube channel | | `publishedAt` | string or null | ISO 8601 date when the video was published (`YYYY-MM-DDTHH:MM:SSZ`) | | `duration` | string or null | Video duration in ISO 8601 format (e.g., `PT5M30S`, `PT1H2M15S`) | | `viewCount` | integer or null | Number of views | | `likeCount` | integer or null | Number of likes | | `commentCount` | integer or null | Number of comments | | `tags` | array | Array of video tags/keywords | | `thumbnailUrl` | string or null | URL to the video thumbnail image | | `transcript` | string or null | Video transcript/subtitles as plain text (null if not requested or unavailable) | | `error` | string or null | Error message if extraction failed (null on success) | #### Example Output JSON ```json { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "title": "Rick Astley - Never Gonna Give You Up (Official Music Video)", "channel": "Rick Astley", "channelUrl": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw", "publishedAt": "2009-10-25T00:00:00Z", "duration": "PT3M33S", "viewCount": 1500000000, "likeCount": 20000000, "commentCount": 5000000, "tags": ["Rick Astley", "Never Gonna Give You Up", "80s", "pop", "music video"], "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg", "transcript": null, "error": null } ``` #### Example Error Output ```json { "url": "https://www.youtube.com/watch?v=INVALID_ID", "title": null, "channel": null, "channelUrl": null, "publishedAt": null, "duration": null, "viewCount": null, "likeCount": null, "commentCount": null, "tags": [], "thumbnailUrl": null, "transcript": null, "error": "This video is unavailable" } ``` ### API Usage #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/perryay~youtube-video-info-extractor/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "includeTranscript": false, "maxResults": 10 }' ``` #### Python (ApifyClient) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("perryay~youtube-video-info-extractor").call( run_input={ "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "includeTranscript": False, "maxResults": 10 } ) dataset = client.dataset(run["defaultDatasetId"]).list_items() for item in dataset.items: title = item.get("title", "N/A") channel = item.get("channel", "N/A") views = item.get("viewCount", "N/A") error = item.get("error") if error: print(f"[ERROR] {item['url']}: {error}") else: print(f"{title} — {channel} — {views} views") ``` ### Use Cases 1. **Content research and trend analysis** — Extract metadata from hundreds of videos to analyze what drives engagement. Compare view counts, like ratios, and comment volumes across topics, channels, or time periods. 2. **Video archive and backup** — Before taking down or restructuring video content, batch-extract all metadata including tags, descriptions, and timestamps for your records. 3. **NLP and transcript analysis** — Enable transcript extraction to get clean text from thousands of videos. Use the text for summarization, keyword extraction, sentiment analysis, or training custom ML models. 4. **Competitive channel audit** — Extract metadata from a competitor's video library to understand their content strategy — which tags they use, how long their videos are, and what engagement looks like. 5. **SEO and tag research** — Collect tags from top-performing videos in your niche. Identify common keywords and patterns to optimize your own video metadata for discoverability. 6. **Playlist and channel migration** — Moving content between YouTube accounts or platforms? Extract all metadata in advance to preserve titles, descriptions, and tags during the transition. 7. **Content moderation monitoring** — Periodically re-check video metadata to detect changes in titles, descriptions, or availability. Flag videos that have been made private or had their metadata altered. 8. **Dataset creation for ML** — Build training datasets for video recommendation systems, content classification models, or engagement prediction by extracting structured metadata at scale. 9. **Creator portfolio analysis** — For content creators, analyze your own video library to see which tags, titles, and durations correlate with higher engagement. Make data-driven content decisions. 10. **Integration with data pipelines** — Combine with other Apify actors (Domain Intel, Link Quality Analyzer) to build comprehensive media monitoring and analysis pipelines. ### FAQ **Q: What video information can this actor extract?** A: It extracts title, channel name, channel URL, published date (ISO 8601), duration (ISO 8601), view count, like count, comment count, tags, thumbnail URL, and optionally the transcript or subtitles in plain text. **Q: Does the actor download the actual video file?** A: No. The actor only extracts metadata and optionally fetches subtitle text. No video or audio content is downloaded. **Q: How many URLs can I submit at once?** A: The `maxResults` parameter caps the number of videos processed per run (default 10, max 50). The `urls` array can contain more entries, but only the first `maxResults` will be processed. **Q: How long does it take to process a video?** A: Each video takes roughly 2-10 seconds depending on YouTube's response time and network conditions. The actor processes up to 2 videos concurrently. For a batch of 10 videos, expect 15-60 seconds total. **Q: How do transcripts work?** A: When `includeTranscript` is `true`, the actor fetches the best available English subtitle track (manual uploads preferred, auto-generated captions as fallback). If English subtitles are unavailable, it falls back to any available language. The subtitles are converted to clean plain text. **Q: What happens if a video doesn't have subtitles?** A: The `transcript` field will be `null` when no subtitles or captions are available for the video. This is not treated as an error — the rest of the metadata is returned normally. **Q: Can the actor extract info from age-restricted videos?** A: Age-restricted videos return an error message: "This video is age-restricted and cannot be accessed without authentication." Other videos in the batch are unaffected. **Q: What about private, deleted, or unavailable videos?** A: Each of these scenarios is detected and reported in the `error` field with a human-readable message. The actor continues processing the remaining URLs in the batch. **Q: Does it work with YouTube Shorts?** A: Yes. YouTube Shorts URLs (e.g., `https://www.youtube.com/shorts/...`) are supported and return the same metadata structure as regular videos. **Q: Can I extract metadata from a YouTube playlist?** A: This actor processes individual video URLs, not playlists. To extract metadata from an entire playlist, provide each video URL in the `urls` array. For playlist-level extraction, consider dedicated YouTube playlist tools. **Q: Does the actor require a YouTube API key?** A: No. The actor uses yt-dlp, which extracts publicly available metadata without requiring API keys or OAuth authentication. **Q: What error types are handled?** A: The actor handles: private videos, deleted/removed videos, age-restricted content, copyright-blocked videos, region-unavailable content, members-only videos, sign-in-required content, and general network/parsing errors. Each is returned with a descriptive error message per video. **Q: What's the concurrency limit and why?** A: The actor limits simultaneous extractions to 2 to stay within YouTube's comfortable rate limit boundaries. Higher concurrency would risk rate limiting and would not meaningfully improve throughput. **Q: Can I run this actor on a schedule?** A: Yes. The actor has a fully documented API and can be integrated into any automation workflow, scheduler, or CI/CD pipeline via the Apify API. ### Usage & Billing This actor uses Apify's PAY\_PER\_EVENT pricing model. You are charged per event: | Event Name | Price (USD) | Trigger | |------------|-------------|---------| | `apify-actor-start` | $0.020 | Charged on every actor start | | `video-extract` | $0.010 | Charged per video processed | | `transcript-fetch` | $0.010 | Charged when transcript is fetched | | `batch-extract` | $0.005 | Charged per batch run (multiple videos) | Platform infrastructure costs (Apify's compute and storage) are passed through at cost. ### MCP Integration This actor can be used through the [Apify MCP server](https://docs.apify.com/integrations/mcp). Once connected, your MCP client (Claude Desktop, Cursor, etc.) can discover and run this actor from the Apify Store. #### Quick Start 1. **Install the Apify connector** in your MCP client: - **Claude Desktop**: Search for "Apify" in the connector directory, or use the remote server at `https://mcp.apify.com` - **Other clients**: See the [Apify MCP server docs](https://docs.apify.com/integrations/mcp) for setup instructions 2. **Ask your AI assistant** to use the actor. #### Claude Desktop Configuration Add the following to your `claude_desktop_config.json`: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com" } } } ``` On first connection, your browser opens to sign in to Apify and authorize access. #### Bearer Token Alternative For MCP clients that do not support browser-based OAuth (e.g., Cursor, VS Code, Windsurf), use a Bearer token directly: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com", "headers": { "Authorization": "Bearer " } } } } ``` Replace `` with your actual Apify API token from [Apify Console](https://console.apify.com/account/integrations). ### Related Tools - **[Meta Mate](https://apify.com/perryay/meta-mate)** — Extract Open Graph, Twitter Cards, and JSON-LD metadata from URLs - **[Link Quality Analyzer](https://apify.com/perryay/link-quality-analyzer)** — Deep analysis of links including HTTP status, redirect chains, and security posture - **[Domain Intel](https://apify.com/perryay/domain-intel)** — WHOIS lookups, DNS enumeration, and SSL certificate validation for brand protection and domain research - **[UUID Lab](https://apify.com/perryay/uuid-lab)** — Generate and decode UUID v4, v7, and nanoid identifiers for consistent cross-platform user and session tracking - **[Social Media Username Checker](https://apify.com/perryay/social-media-username-checker)** — Check username availability across 50+ social media platforms - **[JSON Studio](https://apify.com/perryay/json-studio)** — Format, validate, diff, transform, and explore JSON documents - **[QR Craft](https://apify.com/perryay/qr-craft)** — Generate high-quality QR codes in PNG or SVG format # Actor input Schema ## `urls` (type: `array`): Array of YouTube video URLs to extract metadata from ## `includeTranscript` (type: `boolean`): Whether to fetch and include video transcript/subtitles (English preferred, auto-generated or manual) ## `maxResults` (type: `integer`): Maximum number of videos to process from the URL list ## Actor input object example ```json { "urls": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ" ], "includeTranscript": false, "maxResults": 10 } ``` # Actor output Schema ## `results` (type: `string`): YouTube video metadata and transcript extraction results in the default dataset # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "urls": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/youtube-video-info-extractor").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"] } # Run the Actor and wait for it to finish run = client.actor("perryay/youtube-video-info-extractor").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 '{ "urls": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ" ] }' | apify call perryay/youtube-video-info-extractor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/youtube-video-info-extractor", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "YouTube Video Info Extractor — Metadata & Captions API", "description": "Extract YouTube video metadata — title, channel, publish date, duration, view/like/comment counts, tags, thumbnail, transcripts/captions. No API key required — powered by yt-dlp. Supports batch processing of up to 50 videos per run.", "version": "1.0", "x-build-id": "0H1UHFJF9WgEFekvX" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~youtube-video-info-extractor/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-youtube-video-info-extractor", "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/perryay~youtube-video-info-extractor/runs": { "post": { "operationId": "runs-sync-perryay-youtube-video-info-extractor", "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/perryay~youtube-video-info-extractor/run-sync": { "post": { "operationId": "run-sync-perryay-youtube-video-info-extractor", "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": [ "urls" ], "properties": { "urls": { "title": "YouTube Video URLs", "type": "array", "description": "Array of YouTube video URLs to extract metadata from" }, "includeTranscript": { "title": "Include Transcript", "type": "boolean", "description": "Whether to fetch and include video transcript/subtitles (English preferred, auto-generated or manual)", "default": false }, "maxResults": { "title": "Max Results", "minimum": 1, "maximum": 50, "type": "integer", "description": "Maximum number of videos to process from the URL list", "default": 10 } } }, "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 } } } } } } } } } } ```