# Tiktok Video Scraper (`scrapeengine/tiktok-video-scraper`) Actor

🎯 TikTok Video Scraper pulls video data at scale — captions, hashtags, views, likes, comments, shares, audio, author, publish date & video URLs. 📊 Export JSON/CSV. 🔎 Ideal for trend research, competitor tracking, influencer discovery & content strategy. ⚡️

- **URL**: https://apify.com/scrapeengine/tiktok-video-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### Tiktok Video Scraper

Tiktok Video Scraper is a high-accuracy TikTok video scraper tool that extracts structured, public video metadata at scale — captions, hashtags, views, likes, comments, shares, audio, author, publish date, and canonical video URLs. As a reliable TikTok data extractor and TikTok video metadata extractor, it solves the hassle of manual copy-paste by automating bulk collection from post URLs, with optional discovery of related videos per post. Built for marketers, developers, data analysts, and researchers, this TikTok scraper API–ready actor enables trend research, competitor tracking, influencer discovery, and content strategy at scale. 🚀

### What data / output can you get?

Below are real output fields exactly as they appear in the dataset. The examples show how values are structured and formatted.

| Data type | Description | Example value |
| --- | --- | --- |
| id | Video ID | "7251234567890123456" |
| text | Video description/caption | "We raised $40M for #teamwater 💧" |
| createTimeISO | ISO-8601 timestamp derived from createTime | "2025-09-23T16:49:52.000Z" |
| locationCreated | Location/country/region if available | "US" |
| authorMeta.name | Author’s username (uniqueId) | "mrbeast" |
| authorMeta.verified | Author verification flag | true |
| authorMeta.fans | Author follower count | 23200000 |
| playCount | Total views | 16900000 |
| diggCount | Total likes (hearts) | 883800 |
| commentCount | Total comments count | 58800 |
| videoMeta.duration | Video duration in seconds | 39 |
| webVideoUrl | Canonical TikTok video URL | "https://www.tiktok.com/@user/video/7251234567890123456" |

Bonus outputs you can leverage:
- Rich author object: authorMeta (id, name, profileUrl, nickName, verified, signature, bioLink, avatar URLs, follower/friend/video metrics, and more)
- Music metadata: musicMeta (musicId, musicOriginal, musicAuthor, musicName, playUrl, cover image URLs)
- Video metadata: videoMeta (height, width, duration, coverUrl, originalCoverUrl, definition/ratio, format, subtitleLinks)
- Hashtags array with IDs/titles/covers when available
- Engagement counters: shareCount, collectCount, repostCount
- Flags: isAd, isSponsored, isSlideshow, isPinned
- Traceability: submittedVideoUrl (the original input URL)

All results are saved to an Apify dataset, so you can export to JSON, CSV, or Excel for downstream analytics and pipelines. 📊

### Key features

- 🎯 Bold accuracy from native data objects  
  Parses embedded JSON from script tags (__UNIVERSAL_DATA_FOR_REHYDRATION__ / __SIGI_STATE__) for consistent, structured records on every video page.

- 🔎 Related video discovery (per post)  
  Turn on “Scrape related videos” to collect additional items per submitted post — a lightweight TikTok video crawler for broader context.

- 📈 Batch scraping at scale  
  Paste many post URLs and run them in parallel; asynchronous processing delivers fast throughput for bulk jobs and automations.

- 🧩 Complete video metadata & engagement  
  Captures captions, hashtags, timestamps, music details, author profile stats, and engagement metrics (views/likes/comments/shares/saves/reposts).

- 🗂️ Clean exports for analytics  
  Results land in an Apify dataset, ready to export as JSON, CSV, or Excel for BI tools, warehouses, or notebooks.

- 🔐 No login required  
  Works on publicly available TikTok content. No cookies or account needed.

- 🛠️ Developer-ready foundation  
  Built with Python + Playwright for reliability on dynamic pages. Start runs via the Apify API and integrate into TikTok video scraping Python workflows or your internal TikTok scraper API pipelines.

- 🧱 Production infrastructure  
  Runs on Apify’s managed platform with robust logging and retry logic for stable operations.

### How to use Tiktok Video Scraper - step by step

1. Create or log in to your Apify account  
   Open the actor from your Apify dashboard.

2. Open the Tiktok Video Scraper actor  
   You’ll see input fields for post URLs and related-video settings.

3. Add post URLs  
   Paste one or more TikTok video URLs into postURLs. You can also upload/link a text file of URLs for bulk runs.

4. (Optional) Enable related videos  
   Toggle scrapeRelatedVideos to true and set resultsPerPage to the number of related items per post you want to collect. TikTok typically limits related videos to ~12–16.

5. Start the run  
   Click Start. The actor fetches and normalizes data from each URL. When enabled, it also browses to discover related videos.

6. Monitor progress  
   Watch the run logs for status updates (e.g., “Post scraped successfully” and related-video capture counts).

7. Download results  
   When finished, open the run’s Dataset and export to JSON, CSV, or Excel for analysis.

Pro tip: For discovery beyond direct URLs, start runs via the Apify API and provide keyword terms (see Input section). This turns the scraper into a TikTok hashtag scraper–style workflow or a TikTok video URL extractor inside ETL/ELT pipelines.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing trend discovery | Aggregate views, likes, and comments to identify trending formats, sounds, and captions across niches with a TikTok video crawler workflow. |
| Influencer performance benchmarking | Evaluate creators using playCount, diggCount, shareCount, and commentCount to inform partnerships. |
| Competitor campaign tracking | Monitor public posts and challenges to benchmark content and optimize your creative strategy. |
| Hashtag research | Combine captions and hashtags to spot high-performing tags with a repeatable TikTok hashtag scraper approach. |
| Social listening enrichment | Pair video-level metadata with a dedicated comments scraper to analyze sentiment and community reactions. |
| Academic & behavioral research | Study posting times, music usage, and engagement patterns across cohorts using exportable JSON/CSV. |
| Data engineering pipelines | Treat it as a TikTok scraper API source: trigger runs programmatically and sync datasets to warehouses for BI. |

### Why choose Tiktok Video Scraper?

Built for precision, reliability, and scale on public TikTok video data.

- ✅ Accurate, structured fields from native JSON on video pages
- 🔁 Related-video capture for broader context around each post
- ⚡ Async + headless browser stack for speed at scale
- 💻 Developer-friendly (Python under the hood, Apify API for orchestration)
- 🛡️ Public-only data, no login or cookies required
- 💾 Ready-to-export datasets (JSON/CSV/Excel) for analytics
- 🧱 Production-grade infrastructure with retries and robust logging

Compared to browser extensions or unstable scripts, this production-ready TikTok video scraper tool focuses on stable extraction and clean, analytics-ready output.

### Is it legal / ethical to use Tiktok Video Scraper?

Yes — when done responsibly. This actor targets publicly available TikTok content only.

- Public vs. private data: It collects public video pages and their publicly embedded metadata. It does not access private profiles, DMs, or authenticated areas.
- Compliance guidelines:  
  - Scrape only public content you are allowed to process.  
  - Align usage with your local regulations (e.g., GDPR, CCPA).  
  - Respect TikTok’s terms and avoid misuse of personal data.
- Access limitations: The tool does not log in and does not bypass privacy controls.

Always consult your legal team for edge cases or specific compliance questions.

### Input parameters & output format

#### Example JSON input
```json
{
  "postURLs": [
    "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
  ],
  "scrapeRelatedVideos": true,
  "resultsPerPage": 12,
  "keywords": ["clean water", "science"]
}
````

Parameter details:

- postURLs
  - Type: array
  - Description: Add the URLs of posted videos you want to scrape. You can enter URLs one by one, or you can upload or link to a text file.
  - Default: none
  - Required: yes
- scrapeRelatedVideos
  - Type: boolean
  - Description: Tick to scrape related videos for the post URLs you provide. The maximum number of scraped related videos is set by the resultsPerPage count.
  - Default: false
  - Required: no
- resultsPerPage
  - Type: integer
  - Description: Add the number of related videos you want to scrape for each post URL. Applicable when the Scrape related videos option is enabled. Note: TikTok typically limits related videos to 12–16 per video.
  - Default: 10 (min: 1, max: 1,000,000)
  - Required: no

Notes:

- The keywords array is supported in API input by the actor code and will discover video URLs per keyword (up to resultsPerPage per keyword). It is not present in the UI input schema but can be supplied via API.

#### Example JSON output

```json
[
  {
    "id": "7251234567890123456",
    "text": "WE RAISED $40,000,000 FOR #teamwater 🙌",
    "textLanguage": "en",
    "createTime": 1758646192,
    "createTimeISO": "2025-09-23T16:49:52.000Z",
    "locationCreated": "US",
    "isAd": false,
    "authorMeta": {
      "id": "1234567890",
      "name": "mrbeast",
      "profileUrl": "https://www.tiktok.com/@mrbeast",
      "nickName": "MrBeast",
      "verified": true,
      "signature": "Making the world a better place",
      "bioLink": null,
      "originalAvatarUrl": "https://.../avatarLarger.jpg",
      "avatar": "https://.../avatarMedium.jpg",
      "privateAccount": false,
      "roomId": "",
      "ttSeller": false,
      "followDatasetUrl": null,
      "following": 0,
      "friends": 0,
      "fans": 23200000,
      "heart": 500000000,
      "video": 200,
      "digg": 0
    },
    "musicMeta": {
      "musicName": "original sound",
      "musicAuthor": "MrBeast",
      "musicOriginal": true,
      "playUrl": "https://.../music.mp3",
      "coverMediumUrl": "https://.../coverMedium.jpg",
      "originalCoverMediumUrl": "https://.../coverLarge.jpg",
      "musicId": "987654321"
    },
    "webVideoUrl": "https://www.tiktok.com/@mrbeast/video/7251234567890123456",
    "mediaUrls": [],
    "commentsDatasetUrl": null,
    "videoMeta": {
      "height": 1024,
      "width": 576,
      "duration": 39,
      "coverUrl": "https://.../cover.jpg",
      "originalCoverUrl": "https://.../originCover.jpg",
      "definition": "540p",
      "format": "mp4",
      "subtitleLinks": []
    },
    "diggCount": 883800,
    "shareCount": 114800,
    "playCount": 16900000,
    "collectCount": 1200,
    "commentCount": 58800,
    "repostCount": 0,
    "mentions": [],
    "detailedMentions": [],
    "hashtags": [
      { "id": "1234", "name": "teamwater", "title": "Team Water", "cover": "https://.../cover.jpg" }
    ],
    "effectStickers": [],
    "isSlideshow": false,
    "isPinned": false,
    "isSponsored": false,
    "submittedVideoUrl": "https://www.tiktok.com/@mrbeast/video/7251234567890123456"
  }
]
```

Output notes:

- Some fields may be empty or null if not present publicly (e.g., locationCreated, bioLink, subtitleLinks).
- hashtags may include objects with id/name/title/cover when available; otherwise, hashtag names may be listed without extra metadata.
- On network or parsing errors for a given URL, the actor may push an error item with fields: {"error": "<message>", "url": "\<submitted\_url>"}.
- Results are stored in an Apify dataset for easy export to JSON, CSV, or Excel.

### FAQ

#### Does Tiktok Video Scraper require a TikTok login or cookies?

✅ No. It works on publicly available video pages and does not require login or cookies. It extracts structured data directly from public page scripts.

#### Can this TikTok video scraper tool download videos or remove watermarks?

❌ No. This is a TikTok video metadata extractor. It collects metadata, engagement, and URLs, but it does not download video files or remove watermarks. You can export structured results to CSV/JSON/Excel.

#### How many related videos can it scrape per post?

✅ You control this with resultsPerPage. However, TikTok typically limits related items to about 12–16 per video. The actor will capture as many as the platform returns, up to your configured limit.

#### Can I scrape by keyword or hashtag instead of URLs?

✅ Yes, via API input. Provide keywords as an array and the actor will discover video URLs for each term (up to resultsPerPage per keyword) and include them in the scrape. Hashtag terms can be included as keywords to discover relevant videos.

#### What data fields does it return?

✅ It returns IDs, captions, timestamps, author profile details (e.g., authorMeta.name, authorMeta.verified, authorMeta.fans), video engagement (playCount, diggCount, shareCount, commentCount, collectCount, repostCount), musicMeta, videoMeta, hashtags, and webVideoUrl. See the Output section for a full example.

#### Can I use it with API calls or Python?

💻 Yes. Runs can be started via the Apify API, and results can be fetched programmatically to fit TikTok video scraping Python workflows and TikTok scraper API integrations.

#### What formats can I export to?

💾 Results are stored in an Apify dataset. You can export to JSON, CSV, or Excel directly from the run’s dataset.

#### Is there a free trial or subscription?

💡 The actor listing offers a flat monthly plan with trial minutes (e.g., 120 trial minutes available). Check the Apify actor page for current pricing and trial details.

#### Is it legal to scrape TikTok with this tool?

🛡️ Yes, when you collect and use public data responsibly. Avoid private or restricted content, and ensure your use complies with laws such as GDPR/CCPA and TikTok’s terms.

### Final thoughts

Tiktok Video Scraper is built to extract structured, public TikTok video insights at scale. It delivers clean metadata and engagement metrics for marketers, analysts, developers, and researchers, with optional related-video discovery and exports to CSV/JSON/Excel. Developers can orchestrate runs via the Apify API to embed this TikTok video URL extractor into automated workflows. Start extracting smarter TikTok insights for your next trend analysis, campaign, or research project today.

# Actor input Schema

## `postURLs` (type: `array`):

Add the URLs of posted videos you want to scrape. You can enter URLs one by one, or you can upload or link to a text file.

## `scrapeRelatedVideos` (type: `boolean`):

Tick to scrape related videos for the post URLs you provide. The maximum number of scraped related videos is set by the resultsPerPage count.

## `resultsPerPage` (type: `integer`):

Add the number of related videos you want to scrape for each post URL. This field is applicable when the Scrape related videos option is enabled. Note: TikTok typically limits related videos to 12-16 per video.

## Actor input object example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
  ],
  "scrapeRelatedVideos": false,
  "resultsPerPage": 10
}
```

# 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 = {
    "postURLs": [
        "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeengine/tiktok-video-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "postURLs": ["https://www.tiktok.com/@apifyoffice/video/7200360993149553925"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapeengine/tiktok-video-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "postURLs": [
    "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
  ]
}' |
apify call scrapeengine/tiktok-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Video Scraper",
        "description": "🎯 TikTok Video Scraper pulls video data at scale — captions, hashtags, views, likes, comments, shares, audio, author, publish date & video URLs. 📊 Export JSON/CSV. 🔎 Ideal for trend research, competitor tracking, influencer discovery & content strategy. ⚡️",
        "version": "0.2",
        "x-build-id": "jV8PBrR458JchWRl1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~tiktok-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeengine~tiktok-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeengine~tiktok-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "postURLs"
                ],
                "properties": {
                    "postURLs": {
                        "title": "Direct URL(s) for scraping specific video(s)",
                        "type": "array",
                        "description": "Add the URLs of posted videos you want to scrape. You can enter URLs one by one, or you can upload or link to a text file.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeRelatedVideos": {
                        "title": "Scrape related videos",
                        "type": "boolean",
                        "description": "Tick to scrape related videos for the post URLs you provide. The maximum number of scraped related videos is set by the resultsPerPage count.",
                        "default": false
                    },
                    "resultsPerPage": {
                        "title": "Number of related videos per post",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Add the number of related videos you want to scrape for each post URL. This field is applicable when the Scrape related videos option is enabled. Note: TikTok typically limits related videos to 12-16 per video.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
