# TikTok AIO Scraper (`scrapesmith/tiktok-aio-scraper`) Actor

🔥0.30/1000 results🔥Scrape TikTok profiles, full video feeds, hashtags, playlists, search (Top/Users/Photos/Sounds), followers, and comments — all in one actor. No-watermark downloads, subtitles, slideshows, ad flags. Streaming output, auto-retries, zero setup. JSON/CSV/Excel. API & MCP ready.

- **URL**: https://apify.com/scrapesmith/tiktok-aio-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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

## TikTok All-In-One Scraper

The most complete TikTok data extraction tool on Apify. One actor replaces six separate scrapers — pull creator profiles, entire video feeds, hashtag content, playlists, search results across four tabs, follower lists, and full comment threads, all from a single run. No TikTok account needed, no cookies to paste, no API keys. Just add your targets and go.

### What you can extract

#### Profiles
Get detailed creator info for any public TikTok account: unique ID, nickname, bio, avatar URLs, verification status, follower/following/heart/video counts, account creation date, live-streaming status, commerce flags, and privacy settings. Pass one username or thousands — the scraper fans them out automatically.

#### Posts (full video feed)
Pull a creator's **entire** video catalog — not just the latest 30. Every video comes with a direct no-watermark download link, engagement stats (plays, likes, shares, comments, saves), hashtags, music info, subtitle/caption data, slideshow images for photo posts, and flags for ads, pinned content, and sponsored posts. Tested against accounts with 16,000+ videos — returns every single one.

#### Comments
Extract all comments from any TikTok video, including nested reply threads. Each comment includes the author's profile info, like count, creation timestamp, mentions, hashtags, and any attached images. Configure reply depth per comment. Handles videos with thousands of comments.

#### Search
Search TikTok across four tabs:

- **Top** — mixed results: videos, users, and hashtags matching your query
- **Users** — creator profiles matching your search term
- **Photos** — slideshow/photo posts matching your query
- **Sounds** — music and audio tracks with play counts, artist info, album art, and usage stats

Each search mode paginates deep into TikTok's results — no artificial caps imposed by the scraper.

#### Hashtags
Pull all content under any TikTok hashtag. Works with or without the `#` prefix. Returns the same rich video objects as Posts mode, tagged with the source hashtag for easy filtering.

#### Followers
Get a creator's follower list with full profile details: user ID, username, nickname, avatar, verification status, bio, and follower/following/video counts. Works on any public account.

#### Single video
Grab full metadata for one or more specific TikTok videos by URL. Returns the same detailed video object as Posts mode — stats, download link, music, hashtags, subtitles, slideshow images.

#### Playlists
Extract all videos from a TikTok playlist by URL. Returns complete video objects with the same fields as Posts mode.

### Why this scraper

- **One actor, every TikTok surface.** No need to juggle multiple scrapers for a single project — profiles, posts, comments, search, followers, hashtags, videos, and playlists all run from one input box.
- **No-watermark download links on every video.** Every video record ships a direct, ready-to-download link. No separate "downloader" tool required.
- **Subtitles and slideshow images included.** Auto-captions and photo-post slideshow images are extracted automatically wherever TikTok provides them.
- **Ad, pinned, and sponsored flags** on every video so you can filter organic content from promotions in one pass.
- **Zero setup.** No login, no cookies, no API keys. Just add usernames, links, hashtags, or search terms and run.
- **Auto-detects what you want.** Paste a profile link and get profile info. Paste a video link and get that video. Type a phrase and get search results. One input box handles everything.
- **Streaming output.** Results appear in the dataset as they're scraped — not batched at the end. Abort or migrate at any time without losing data.
- **Resilient.** Built-in retry logic with automatic recovery from transient failures. State is checkpointed so nothing is lost on platform restarts.
- **Fast and cheap.** Built for both quick single lookups and large batch jobs. Typical cost is under $0.01 per 1,000 results for most modes.

### Input

| Field | What it does |
|---|---|
| `input` | List of usernames (`@handle`), TikTok links (profile / video / hashtag / playlist), or search phrases. Mix and match — each entry is handled independently. |
| `mode` | Leave on **Auto-detect**, or force one mode for every entry: Profile, Posts, Hashtag, Video, Search, Followers, Comments, or Playlist. Auto-detect reads `@handle` as Profile, `#tag` as Hashtag, a `/video/` link as Video, and anything else as Search. |
| `searchType` | For Search mode: Top (mixed), Users, Photos, or Sounds. |
| `maxItems` | Cap on results per input entry. Set high (e.g. 50000) to get everything available. |
| `includeReposts` | Posts mode: also pull videos the creator reposted from other accounts. |
| `includeReplies` | Comments mode: also pull nested reply threads under each top-level comment. |
| `maxRepliesPerComment` | Comments mode: cap on replies per top-level comment. |
| `cookies` | Optional. Paste your browser's TikTok cookie string for deeper search pagination. |
| `proxyConfiguration` | Optional. Only needed for Search > Users tab. All other modes work without proxies. |

### Output examples

#### Video record (Posts, Hashtag, Search/Top, Search/Photos, Video, Playlist)

```json
{
  "id": "7444533247402495240",
  "desc": "chasing golden hour again",
  "createTime": 1733310671,
  "createTimeISO": "2024-12-04T12:31:11.000Z",
  "webVideoUrl": "https://www.tiktok.com/@creator/video/7444533247402495240",
  "author": {
    "uniqueId": "creator",
    "nickname": "Creator Name",
    "verified": false,
    "followerCount": 128000
  },
  "stats": {
    "digg": 515,
    "play": 75900,
    "share": 233,
    "comment": 12,
    "collect": 111
  },
  "video": {
    "playAddr": "https://...mp4",
    "cover": "https://...jpg",
    "duration": 14,
    "width": 1080,
    "height": 1920,
    "subtitleInfos": []
  },
  "music": {
    "id": "744453324",
    "title": "original sound",
    "author": "creator",
    "playUrl": "https://..."
  },
  "hashtags": ["goldenhour", "sunset"],
  "isAd": false,
  "isPinned": false,
  "isSponsored": false,
  "isSlideshow": false,
  "slideshowImages": [],
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}
````

#### Profile record (Profile, Followers)

```json
{
  "id": "6940000000000000000",
  "uniqueId": "tiktok",
  "nickname": "TikTok",
  "signature": "Make your day",
  "bioLink": "https://linktr.ee/tiktok",
  "avatarUrl": "https://...jpg",
  "verified": true,
  "privateAccount": false,
  "followerCount": 85600000,
  "followingCount": 892,
  "heartCount": 3200000000,
  "videoCount": 1450,
  "diggCount": 12000,
  "friendCount": 200,
  "createTimeISO": "2017-09-20T00:00:00Z",
  "isLive": false,
  "profileUrl": "https://www.tiktok.com/@tiktok",
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}
```

#### Comment record

```json
{
  "commentId": "7444533247402495001",
  "text": "This is so beautiful!",
  "createTimeISO": "2024-12-04T13:00:00.000Z",
  "likes": 42,
  "replyCount": 3,
  "author": {
    "uniqueId": "commenter",
    "nickname": "Commenter",
    "avatarUrl": "https://...jpg"
  },
  "mentions": [],
  "hashtags": [],
  "images": [],
  "replies": []
}
```

#### Music/Sound record (Search/Sounds)

```json
{
  "id": "744453324",
  "title": "original sound",
  "author": "creator",
  "album": "",
  "duration": 30,
  "playUrl": "https://...",
  "coverUrl": "https://...",
  "userCount": 15000,
  "isOriginal": true,
  "resultType": "music"
}
```

### Use cases

- **Creator research and competitor tracking** — pull a competitor's full feed, engagement stats, posting cadence, and hashtag strategy in one run. Compare multiple creators side by side.
- **Trend and hashtag monitoring** — track what's rising under a hashtag or sound this week. Run on a schedule to build a time series of trending content.
- **Content licensing and archiving** — grab direct video and slideshow URLs for approved re-use, backup, or compliance archiving.
- **Audience and influencer analysis** — map follower graphs, discover verified accounts in a niche, track growth over time, and identify micro-influencers by follower-to-engagement ratio.
- **Social listening and sentiment analysis** — pull comment threads at scale to analyze audience sentiment, identify FAQ patterns, and surface product feedback.
- **Lead generation** — surface creator contact info (bios, bio links) at scale via search + profile. Find creators in any niche by searching keywords and pulling their profiles.
- **Music and sound discovery** — search the Sounds tab to find trending audio tracks, see usage counts, and identify emerging sounds before they peak.
- **Academic and market research** — collect structured datasets of TikTok content for analysis. Clean JSON/CSV/Excel export makes it easy to load into any analysis tool.
- **Content moderation and brand safety** — monitor mentions, hashtags, and comment threads at scale to catch brand-safety issues early.
- **Recruitment and talent scouting** — search for creators in specific niches, pull their audience metrics, and export contact info for outreach campaigns.

### Performance and limits

| Mode | Typical depth | Speed |
|---|---|---|
| Posts | Full account (16,000+ tested) | ~18 videos/sec |
| Comments | 4,600+ per video | ~27 comments/sec |
| Followers | 2,400 per account | ~21 users/sec |
| Profile | Unlimited (1 per username) | ~3.5 profiles/sec |
| Video | Unlimited (1 per URL) | ~19 videos/sec |
| Search/Top | ~200+ per query | ~5 results/sec |
| Search/Users | ~300+ per query | ~10 users/sec |
| Search/Sounds | ~300+ per query | ~6 results/sec |
| Search/Photos | ~80+ per query | ~4 results/sec |
| Hashtag | ~100+ per tag | ~4 results/sec |

Search depth varies by query popularity and TikTok's internal ranking. The scraper paginates until TikTok stops returning results — no artificial limits imposed.

### Proxy

Most modes work without any proxy at all. The only exception is **Search > Users**, which requires a proxy to return results. For that mode, enable Apify Proxy in the proxy configuration input. All other modes — Posts, Comments, Followers, Profile, Video, Playlist, Search/Top, Search/Photos, Search/Sounds, and Hashtag — run without proxies.

### API, MCP, and integrations

This actor runs on the Apify platform and works out of the box with:

- **Apify API** — trigger runs, fetch results, and manage datasets programmatically from any language
- **Apify MCP Server** — drop it straight into Claude, ChatGPT, or any MCP-compatible AI agent as a tool
- **Webhooks** — get notified when a run completes and automatically process the results
- **Scheduled runs** — set up recurring scrapes on any interval (hourly, daily, weekly)
- **n8n, Make, Zapier** — connect via built-in Apify integrations for no-code automation
- **JSON / CSV / Excel export** — download results in any format directly from the dataset

### FAQ

**Do I need a TikTok account or cookies?**
No. Everything here is public data — no login required. The optional cookies field can improve search depth but is not necessary.

**Can I download videos without a watermark?**
Yes — every video result includes a direct download link with no watermark overlay.

**Does it work on private accounts?**
No. Only public TikTok content is accessible, same as opening TikTok in a browser while logged out.

**What counts as one result?**
Each video, user profile, comment, or sound returned counts as one result.

**Why does Search/Users need a proxy?**
This particular search tab requires a proxy to return results. All other search tabs and modes work without any proxy.

**Can I scrape a creator's following list (who they follow)?**
No. TikTok restricts this data for public access. This is a platform-level restriction, not a scraper limitation.

**How much does it cost to run?**
Typical cost is under $0.01 per 1,000 results for most modes. See Apify's pricing page for current rates.

**Can I run this on a schedule?**
Yes — use Apify's built-in scheduler to run it hourly, daily, or on any custom interval.

**What happens if the run is interrupted?**
Results are streamed to the dataset as they're scraped, not batched at the end. If a run is aborted or migrated, you keep everything that was already collected. The scraper automatically retries on transient failures — it doesn't give up after one error.

**What's the difference between Posts and Video mode?**
Posts mode pulls a creator's entire video feed (all their uploads). Video mode pulls metadata for one specific video by URL. Use Posts when you want everything from a creator, Video when you want details on specific videos.

**Can I mix different types of input in one run?**
Yes. You can put usernames, video URLs, hashtags, and search terms in the same input list. Each entry is processed independently — the scraper auto-detects what each one is and fetches accordingly.

# Actor input Schema

## `input` (type: `array`):

One or more TikTok usernames (@handle), profile/video/hashtag/playlist URLs, or free-text search queries. What each one returns depends on 'mode' — leave mode on Auto-detect to let the shape of each entry decide, or force a specific mode below.

## `mode` (type: `string`):

What to do with every entry in 'input'. Auto-detect reads @handle as Profile, #tag as Hashtag, a /video/ link as Video, and anything else as Search. Pick a specific mode to force it for every entry instead — e.g. to pull a creator's full video feed (Posts) rather than just their profile info, or to fetch Followers/Comments (which auto-detect never picks on its own).

## `searchType` (type: `string`):

Only used when mode is Search: which TikTok search tab to pull from — Top (mixed videos/users/hashtags), Users, Photos (slideshow posts), or Sounds.

## `maxItems` (type: `integer`):

Cap on how many results to return for EACH entry in 'input' (each video, user, comment, etc. counts as one result).

## `includeReposts` (type: `boolean`):

Posts mode only: also include videos the creator reposted from other accounts, not just their own uploads.

## `includeReplies` (type: `boolean`):

Comments mode only: also fetch nested reply threads under each top-level comment.

## `maxRepliesPerComment` (type: `integer`):

Comments mode only, used when 'Include comment replies' is on: cap on how many replies to fetch per top-level comment.

## Actor input object example

```json
{
  "input": [
    "@tiktok"
  ],
  "mode": "auto",
  "searchType": "general",
  "maxItems": 30,
  "includeReposts": false,
  "includeReplies": false,
  "maxRepliesPerComment": 20
}
```

# 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 = {
    "input": [
        "@tiktok"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/tiktok-aio-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 = { "input": ["@tiktok"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/tiktok-aio-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 '{
  "input": [
    "@tiktok"
  ]
}' |
apify call scrapesmith/tiktok-aio-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok AIO Scraper",
        "description": "🔥0.30/1000 results🔥Scrape TikTok profiles, full video feeds, hashtags, playlists, search (Top/Users/Photos/Sounds), followers, and comments — all in one actor. No-watermark downloads, subtitles, slideshows, ad flags. Streaming output, auto-retries, zero setup. JSON/CSV/Excel. API & MCP ready.",
        "version": "0.1",
        "x-build-id": "2A5p9i2CbmItc9bqF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~tiktok-aio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-tiktok-aio-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/scrapesmith~tiktok-aio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-tiktok-aio-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/scrapesmith~tiktok-aio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-tiktok-aio-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": [
                    "input"
                ],
                "properties": {
                    "input": {
                        "title": "Usernames, URLs, hashtags, or search queries",
                        "type": "array",
                        "description": "One or more TikTok usernames (@handle), profile/video/hashtag/playlist URLs, or free-text search queries. What each one returns depends on 'mode' — leave mode on Auto-detect to let the shape of each entry decide, or force a specific mode below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "auto",
                            "profile",
                            "posts",
                            "hashtag",
                            "video",
                            "search",
                            "followers",
                            "comments",
                            "playlist"
                        ],
                        "type": "string",
                        "description": "What to do with every entry in 'input'. Auto-detect reads @handle as Profile, #tag as Hashtag, a /video/ link as Video, and anything else as Search. Pick a specific mode to force it for every entry instead — e.g. to pull a creator's full video feed (Posts) rather than just their profile info, or to fetch Followers/Comments (which auto-detect never picks on its own).",
                        "default": "auto"
                    },
                    "searchType": {
                        "title": "Search tab",
                        "enum": [
                            "general",
                            "user",
                            "photo",
                            "music"
                        ],
                        "type": "string",
                        "description": "Only used when mode is Search: which TikTok search tab to pull from — Top (mixed videos/users/hashtags), Users, Photos (slideshow posts), or Sounds.",
                        "default": "general"
                    },
                    "maxItems": {
                        "title": "Max results per input entry",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on how many results to return for EACH entry in 'input' (each video, user, comment, etc. counts as one result).",
                        "default": 30
                    },
                    "includeReposts": {
                        "title": "Include reposts",
                        "type": "boolean",
                        "description": "Posts mode only: also include videos the creator reposted from other accounts, not just their own uploads.",
                        "default": false
                    },
                    "includeReplies": {
                        "title": "Include comment replies",
                        "type": "boolean",
                        "description": "Comments mode only: also fetch nested reply threads under each top-level comment.",
                        "default": false
                    },
                    "maxRepliesPerComment": {
                        "title": "Max replies per comment",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Comments mode only, used when 'Include comment replies' is on: cap on how many replies to fetch per top-level comment.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
