# Youtube + Tiktok + Instagram + X/Twitter Video Extractor (`swift_emperor/youtube-tiktok-instagram-twitter-video-extractor`) Actor

Extract video metadata, stats, comments, and download videos from Youtube, Tiktok, Instagram and X/Twitter. Batch support with parallel processing. Get views, likes, shares, retweets, bookmarks, saves, follower counts, creator info and comments, all in one actor.

- **URL**: https://apify.com/swift\_emperor/youtube-tiktok-instagram-twitter-video-extractor.md
- **Developed by:** [Gabriel Onicala](https://apify.com/swift_emperor) (community)
- **Categories:** Videos, Social media, Developer tools
- **Stats:** 40 total users, 9 monthly users, 84.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 video extractions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 TikTok Instagram Twitter Video Metadata Scraper

Extract video metadata, engagement stats, comments, and MP4 downloads from **YouTube**, **TikTok**, **Instagram**, and **Twitter/X** — all in one actor. No official API needed. Supports batch processing with parallel extraction.

---

### What does this actor do?

This video metadata scraper lets you pass one or more video URLs from YouTube, TikTok, Instagram, or Twitter/X and get back a rich, normalized JSON response for each video. Whether you need YouTube video stats, TikTok engagement data, Instagram Reels data, or Twitter video metadata, this actor handles all four platforms in a single run.

For each URL you get:

- **Video metadata** — title, description, duration, upload date, tags, thumbnail
- **Engagement stats** — views, likes, comments count (where the platform allows), shares (TikTok), retweets & bookmarks (Twitter/X), saves (TikTok)
- **Creator info** — name, username, profile URL, follower count, avatar
- **Video download** — MP4 videos downloaded and hosted for you (optional)
- **Comments** — top-level comments with author info, text, likes, and timestamps (YouTube, TikTok, Instagram, and Twitter/X)

---

### Supported platforms

| Platform | Metadata | Stats | Comments | Video Download |
|----------|----------|-------|----------|----------------|
| YouTube  | ✅ | Views, likes, comments, subscribers | ✅ | ✅ Direct URL |
| TikTok   | ✅ | Views, likes, shares, saves, comments, followers | ✅ | ✅ Hosted MP4 |
| Instagram | ✅ | Likes, comments, followers | ✅ | ✅ Direct URL |
| Twitter/X | ✅ | Views, likes, retweets, bookmarks, comments, followers | ✅ | ✅ Hosted MP4 |

---

### YouTube

Extract YouTube video metadata and stats without the official YouTube Data API — no API key or quota limits required. Get video titles, descriptions, view counts, like counts, subscriber counts, tags, thumbnails, upload dates, and top comments. Optionally download the MP4 directly.

**Common YouTube use cases:**
- Scrape YouTube video stats for competitive analysis
- Extract YouTube engagement data for UGC research
- Download YouTube videos for archival or processing
- Build datasets of YouTube video metadata for ML pipelines

**Supported YouTube URL formats:**
````

https://www.youtube.com/watch?v=VIDEO\_ID
https://youtu.be/VIDEO\_ID
https://www.youtube.com/shorts/VIDEO\_ID

```

---

### TikTok

Extract TikTok video data including views, likes, shares, saves, follower counts, and comments. Download TikTok videos as MP4 files hosted on Apify's infrastructure. No TikTok API key needed.

**Common TikTok use cases:**
- Extract TikTok video stats for influencer analysis
- Scrape TikTok engagement metrics for brand campaigns
- Download TikTok videos for content archival
- Analyze TikTok creator performance across multiple videos

**Supported TikTok URL formats:**
```

https://www.tiktok.com/@username/video/VIDEO\_ID

```

---

### Instagram

Extract Instagram Reels and video-post metadata — title/caption, description, thumbnail, duration, upload date, like count, comment count, and follower count — plus creator info and top-level comments, and get back a direct MP4 download URL (no hosting delay, works like YouTube).

> **Note:** Instagram comment extraction is supported (top-level comments with author, text, likes, and reply counts). Because Instagram rotates the internal identifiers behind its comment feed every few weeks, comment extraction can occasionally return empty for a short window until the actor's configuration is refreshed — the response carries a `note` when this happens, and metadata, stats, and downloads are unaffected.

**Common Instagram use cases:**
- Scrape Instagram Reels comments and stats (likes, follower counts) for influencer research
- Extract Instagram video metadata for UGC and content licensing workflows
- Download Instagram Reels and video posts for archival before they're removed
- Build cross-platform datasets combining Instagram with YouTube, TikTok, and Twitter/X data

**Supported Instagram URL formats:**
```

https://www.instagram.com/reel/SHORTCODE
https://www.instagram.com/reels/SHORTCODE
https://www.instagram.com/p/SHORTCODE
https://www.instagram.com/tv/SHORTCODE

```

> Note: Instagram image-only posts are not supported — only video content (Reels, video posts, IGTV) can be extracted.

---

### Twitter / X

Extract Twitter/X video metadata, engagement stats (retweets, bookmarks, likes, views), and creator info. Download Twitter videos as hosted MP4 files. Works with both `x.com` and `twitter.com` URLs.

> **Note:** Twitter/X comment extraction requires authenticated session cookies due to platform restrictions.

**Common Twitter/X use cases:**
- Scrape Twitter video stats for social listening
- Extract X video engagement data for trend analysis
- Download Twitter videos before they're deleted
- Monitor creator stats across Twitter accounts

**Supported Twitter/X URL formats:**
```

https://x.com/username/status/TWEET\_ID
https://twitter.com/username/status/TWEET\_ID

````

---

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `urls` | string[] | Yes | One or more video URLs (YouTube, TikTok, Instagram, Twitter/X) |
| `comments` | integer | No | Number of comments per video (0–100, default: 5) |
| `downloadVideos` | boolean | No | Download and host MP4 files. Default: on for single URL, off for batch |

#### Single URL example

```json
{
  "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
  "comments": 10
}
````

#### Batch example (mixed platforms)

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.tiktok.com/@username/video/7123456789012345678",
    "https://www.instagram.com/reel/C1a2B3c4D5e",
    "https://x.com/username/status/1234567890123456789"
  ],
  "comments": 5,
  "downloadVideos": true
}
```

Batch URLs are processed **3 at a time** in parallel. Each URL succeeds or fails independently — one failed URL won't stop the rest.

***

### Output

Each URL produces one JSON object in the default dataset:

```json
{
  "platform": "youtube",
  "video": {
    "id": "dQw4w9WgXcQ",
    "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up",
    "description": "The official video for...",
    "duration": "3:33",
    "duration_seconds": 213,
    "views": 1500000000,
    "likes": 16000000,
    "total_comments": 3200000,
    "thumbnail": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
    "download_url": "https://...",
    "upload_date": "2009-10-25",
    "tags": ["rick astley", "never gonna give you up"]
  },
  "creator": {
    "name": "Rick Astley",
    "username": "@RickAstleyYT",
    "profile_url": "https://www.youtube.com/@RickAstleyYT",
    "channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
    "subscribers": 8400000,
    "avatar": null
  },
  "comments": [
    {
      "author": "@username",
      "author_url": "https://www.youtube.com/@username",
      "author_thumbnail": "https://...",
      "text": "This song never gets old!",
      "likes": 42,
      "is_favorited": false,
      "parent": "root",
      "timestamp": "2024-01-15T12:00:00.000Z"
    }
  ],
  "_meta": {
    "extracted_at": "2026-02-24T17:31:30.418Z",
    "source_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "extractor": "youtube",
    "comments_requested": 10,
    "comments_returned": 10
  }
}
```

#### Platform-specific fields

- **TikTok only**: `video.shares`, `video.saves`
- **Instagram only**: `video.shortcode`
- **Twitter/X only**: `video.retweets`, `video.bookmarks`, `video.has_video`, `creator.handle`

#### Video downloads

When `downloadVideos` is enabled:

- **YouTube & Instagram**: `download_url` is a direct MP4 link (works in any browser)
- **TikTok & Twitter/X**: Videos are downloaded and stored in Apify's key-value store. `download_url` points to the hosted file

***

### Performance

| Batch size | Estimated time |
|------------|----------------|
| 1 URL | ~4–8 seconds |
| 3 URLs | ~5–10 seconds (parallel) |
| 10 URLs | ~15–25 seconds |

***

### Use cases

- **UGC analysis** — evaluate user-generated content across YouTube, TikTok, Instagram, and Twitter/X for ad campaign potential
- **Social media monitoring** — track video engagement metrics and creator stats across all major platforms
- **Influencer research** — compare follower counts, view rates, and engagement across creators
- **Content archival** — save video metadata and MP4 downloads before content is removed
- **Competitive analysis** — benchmark creator performance on YouTube, TikTok, Instagram, and Twitter/X simultaneously
- **Dataset building** — build labeled video metadata datasets for ML, NLP, or analytics
- **Comment sentiment analysis** — extract comments from YouTube, TikTok, Instagram, and Twitter/X videos at scale

***

### Why use this instead of platform APIs?

The official YouTube Data API, TikTok Research API, and Twitter/X API all have strict rate limits, require approval processes, and charge for heavy usage. This actor simplifies data collection — no API keys, no quota worries, just pass in URLs and get data back.

It's also the only actor that extracts video metadata from YouTube, TikTok, Instagram, and Twitter/X in a single unified call with a consistent output schema, which saves you from running and maintaining four separate scrapers.

***

### Limitations

- Instagram comment extraction can briefly return empty when Instagram rotates its internal comment-feed identifiers (auto-flagged with a `note`); metadata, stats, and downloads are unaffected
- Twitter/X comment extraction requires authenticated session cookies
- YouTube and Instagram download URLs are direct and expire after a few hours
- TikTok and Twitter/X download URLs are hosted temporarily in Apify's key-value store
- Instagram view counts are often unavailable for Reels (platform/extraction limitation) — likes and follower counts are reliable
- Some platforms may rate-limit requests from the same IP under heavy load
- Maximum video download size: 200MB

***

### FAQ

**Can I scrape YouTube video stats without the YouTube Data API?**
Yes. This actor extracts YouTube video metadata, view counts, likes, subscriber counts, and comments without requiring a YouTube API key or hitting any quota limits.

**Does this work for TikTok videos?**
Yes. Pass any TikTok video URL and get back views, likes, shares, saves, follower count, comments, and an optional hosted MP4 download.

**Does this extract Instagram data?**
Yes — Instagram Reels and video-post metadata, likes, comment count, follower counts, creator info, top-level comments, and MP4 downloads are all supported. Instagram rotates the internal identifiers behind its comment feed every few weeks, so comment extraction may occasionally return empty for a short window (flagged with a `note`) until the actor is refreshed; metadata and downloads are unaffected.

**Can I download Twitter/X videos?**
Yes. When `downloadVideos` is enabled, Twitter/X videos are downloaded and stored as MP4 files in Apify's key-value store with a direct download URL.

**Can I process YouTube, TikTok, Instagram, and Twitter URLs in the same batch?**
Yes — that's the main advantage of this actor. Mix URLs from all four platforms in the `urls` array and get back a normalized JSON response for each, with platform-specific fields clearly labeled.

**How is this different from a dedicated YouTube scraper or TikTok scraper?**
Dedicated scrapers only handle one platform. If you're doing cross-platform analysis (e.g. comparing the same creator's performance on YouTube vs TikTok vs Instagram vs Twitter), you'd normally need four separate actors. This one handles all four with a consistent output format.

**Does it extract comments from TikTok, Instagram, and Twitter?**
Yes for TikTok and Instagram. For Twitter/X, comment extraction requires you to provide authenticated session cookies due to platform login requirements.

**What video URL formats are supported?**
YouTube: `youtube.com/watch`, `youtu.be`, and `youtube.com/shorts` links. TikTok: standard `tiktok.com/@user/video/ID` links. Instagram: `instagram.com/reel/`, `/reels/`, `/p/`, and `/tv/` links (video content only). Twitter/X: both `x.com` and `twitter.com` status URLs.

**Is there a free trial?**
New Apify users get a free platform credit on signup which you can use to test this actor before committing to a paid plan.

# Actor input Schema

## `urls` (type: `array`):

One or more video URLs to extract. Processed in parallel (3 at a time).

## `comments` (type: `integer`):

How many comments to extract per video (0-100)

## `downloadVideos` (type: `boolean`):

Download videos and store them in the key-value store. Default: on for single URL, off for batch (to save time).

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=gkr_Sn_XtN8",
    "https://www.tiktok.com/@jikazzuki/video/7609068445363178775",
    "https://www.instagram.com/reels/DZNbpe_uYnd/",
    "https://x.com/Kick_Champ/status/2025224078357889237"
  ],
  "comments": 5
}
```

# Actor output Schema

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

Video metadata, engagement stats, creator info, comments, and direct MP4 download URL.

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=gkr_Sn_XtN8",
        "https://www.tiktok.com/@jikazzuki/video/7609068445363178775",
        "https://www.instagram.com/reels/DZNbpe_uYnd/",
        "https://x.com/Kick_Champ/status/2025224078357889237"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("swift_emperor/youtube-tiktok-instagram-twitter-video-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": [
        "https://www.youtube.com/watch?v=gkr_Sn_XtN8",
        "https://www.tiktok.com/@jikazzuki/video/7609068445363178775",
        "https://www.instagram.com/reels/DZNbpe_uYnd/",
        "https://x.com/Kick_Champ/status/2025224078357889237",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("swift_emperor/youtube-tiktok-instagram-twitter-video-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=gkr_Sn_XtN8",
    "https://www.tiktok.com/@jikazzuki/video/7609068445363178775",
    "https://www.instagram.com/reels/DZNbpe_uYnd/",
    "https://x.com/Kick_Champ/status/2025224078357889237"
  ]
}' |
apify call swift_emperor/youtube-tiktok-instagram-twitter-video-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=swift_emperor/youtube-tiktok-instagram-twitter-video-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube + Tiktok + Instagram + X/Twitter Video Extractor",
        "description": "Extract video metadata, stats, comments, and download videos from Youtube, Tiktok, Instagram and X/Twitter. Batch support with parallel processing. Get views, likes, shares, retweets, bookmarks, saves, follower counts, creator info and comments, all in one actor.",
        "version": "1.0",
        "x-build-id": "aMQdZbdA2sYWl8far"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swift_emperor~youtube-tiktok-instagram-twitter-video-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swift_emperor-youtube-tiktok-instagram-twitter-video-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/swift_emperor~youtube-tiktok-instagram-twitter-video-extractor/runs": {
            "post": {
                "operationId": "runs-sync-swift_emperor-youtube-tiktok-instagram-twitter-video-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/swift_emperor~youtube-tiktok-instagram-twitter-video-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-swift_emperor-youtube-tiktok-instagram-twitter-video-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": "Video URLs",
                        "type": "array",
                        "description": "One or more video URLs to extract. Processed in parallel (3 at a time).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "comments": {
                        "title": "Number of comments",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many comments to extract per video (0-100)",
                        "default": 5
                    },
                    "downloadVideos": {
                        "title": "Download videos",
                        "type": "boolean",
                        "description": "Download videos and store them in the key-value store. Default: on for single URL, off for batch (to save time)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
