# TikTok User Search Scraper - Creator Profiles (`khadinakbar/tiktok-user-search-scraper`) Actor

Search TikTok users by keyword and extract public creator profiles with handles, bios, follower counts, verification, avatars, and profile URLs. Provider-backed, no cookies, MCP ready.

- **URL**: https://apify.com/khadinakbar/tiktok-user-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 profile scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are 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 User Search Scraper - Creator Profiles

TikTok User Search Scraper finds public TikTok users and creators by keyword, name, niche, or brand query. It returns normalized creator profile rows with handles, profile URLs, bios, follower counts, following counts, total likes, video counts, verification data, avatars, private-account flags, and provider provenance. Use it for influencer discovery, creator lead generation, social listening, talent scouting, competitor research, and AI-agent workflows that need a clean TikTok creator shortlist from a search term.

### What is TikTok User Search Scraper?

TikTok User Search Scraper is a focused TikTok creator discovery actor. Instead of mixing video, hashtag, comment, and follower modes into one broad tool, it does one job: search TikTok users by public keyword and return structured profile records. The actor is provider-backed with ScrapeCreators as the default primary provider and SociaVault as a fallback, so users do not need TikTok cookies, browser sessions, or residential proxy setup.

Each saved dataset row is one public TikTok user profile. The output is designed for AI agents and MCP clients that need predictable field names such as `username`, `profileUrl`, `bio`, `followerCount`, `verified`, `avatarUrl`, and `scrapedAt`.

### Use cases for TikTok user data

- Build creator shortlists for influencer marketing campaigns.
- Find micro-influencers in a niche by keyword and minimum follower count.
- Discover creators mentioning a brand, competitor, product category, or creator name.
- Seed a CRM with public creator handles and profile metadata.
- Monitor official or verified creator accounts for brand safety research.
- Map creator markets by query, audience size, and profile positioning.
- Run AI-agent research workflows that need a compact list of TikTok profiles.

### What data can I extract with TikTok User Search Scraper?

| Field | Description |
| --- | --- |
| `query` | Search term that produced the row. |
| `username` | TikTok handle from the user search result. |
| `profileUrl` | Public TikTok profile URL. |
| `nickname` | Display name. |
| `bio` | Profile bio, signature, or search description. |
| `bioLink` | Public bio link when returned. |
| `verified` | Verification flag derived from TikTok/provider metadata. |
| `customVerify` | Verification label when returned. |
| `avatarUrl` | Largest available profile image URL. |
| `followerCount` | Follower count. |
| `followingCount` | Following count. |
| `heartCount` | Total likes received by the profile. |
| `videoCount` | Number of videos posted. |
| `privateAccount` | Whether the account appears private. |
| `provider` | Provider used for the row. |
| `scrapedAt` | Timestamp when the row was saved. |

### How much will scraping TikTok users cost you?

This actor uses pay-per-event pricing.

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 per run |
| Profile scraped | $0.005 per saved profile |

Example costs:

- 10 profiles costs about $0.05005.
- 100 profiles costs about $0.50005.
- 1,000 profiles costs about $5.00005.

Filters such as `minFollowerCount`, `verifiedOnly`, and `excludePrivateAccounts` are applied before profile rows are saved and billed. Provider request credits are still consumed during discovery, so keep demo runs small before scaling.

### How to use TikTok User Search Scraper

Start with one or more search queries:

```json
{
  "searchQueries": ["fitness coach", "Taylor Swift"],
  "maxProfilesPerQuery": 25,
  "maxPagesPerQuery": 2,
  "maxTotalProfiles": 50,
  "minFollowerCount": 10000,
  "verifiedOnly": false,
  "excludePrivateAccounts": false,
  "providerOrder": "scrapecreators-first"
}
````

Use `maxProfilesPerQuery` and `maxTotalProfiles` as billing guards. Use `maxPagesPerQuery` to control how far the providers paginate for each query. The `trim` option defaults to false because TikTok user search needs full provider responses for richer profile fields such as bio and verification. Set `includeRawData` only when debugging provider field drift, because raw TikTok payloads are large and less useful for AI-agent runs.

### Output example

```json
{
  "recordType": "user",
  "searchType": "users",
  "provider": "scrapecreators",
  "query": "Taylor Swift",
  "resultPosition": 1,
  "page": 1,
  "cursor": null,
  "userId": "6881290705605477381",
  "userSecUid": "MS4wLjABAAAA...",
  "username": "taylorswift",
  "profileUrl": "https://www.tiktok.com/@taylorswift",
  "nickname": "Taylor Swift",
  "bio": "This is pretty much just a cat account",
  "verified": true,
  "avatarUrl": "https://p16-amd-va.tiktokcdn.com/avatar.jpeg",
  "followerCount": 33800000,
  "followingCount": 0,
  "heartCount": 267837265,
  "videoCount": 88,
  "privateAccount": false,
  "scrapedAt": "2026-07-09T12:00:00.000Z"
}
```

### API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/tiktok-user-search-scraper').call({
  searchQueries: ['beauty creator'],
  maxProfilesPerQuery: 20,
  maxPagesPerQuery: 2,
  minFollowerCount: 5000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### MCP and AI-agent usage

Use this actor when an agent needs to answer questions like "find TikTok creators in the skincare niche with at least 10k followers" or "build a seed list of official Taylor Swift related TikTok profiles." Do not use it for TikTok videos, comments, transcripts, profile feeds, followers, following lists, or no-watermark downloads. Those are separate actors with different output contracts and costs.

The output is intentionally flat and compact so models can inspect several rows without wasting context on raw provider payloads.

### Scrape any TikTok data with dedicated scrapers

Related actors in this portfolio:

- [TikTok Profile Scraper](https://apify.com/khadinakbar/tiktok-profile-scraper)
- [TikTok Profile Videos Scraper](https://apify.com/khadinakbar/tiktok-profile-videos-scraper)
- [TikTok Search Scraper](https://apify.com/khadinakbar/tiktok-search-scraper)
- [TikTok Video Search Scraper](https://apify.com/khadinakbar/tiktok-video-search-scraper)
- [TikTok Video Scraper](https://apify.com/khadinakbar/tiktok-video-scraper)
- [TikTok Video Comments Scraper](https://apify.com/khadinakbar/tiktok-video-comments-scraper)
- [TikTok Followers Scraper](https://apify.com/khadinakbar/tiktok-followers-scraper)
- [TikTok Following Scraper](https://apify.com/khadinakbar/tiktok-following-scraper)
- [TikTok Trending Hashtags Scraper](https://apify.com/khadinakbar/tiktok-trending-hashtags-scraper)
- [TikTok Trending Videos Scraper](https://apify.com/khadinakbar/tiktok-trending-videos-scraper)
- [TikTok Sound Scraper](https://apify.com/khadinakbar/tiktok-sound-scraper)
- [TikTok No Watermark Downloader](https://apify.com/khadinakbar/tiktok-no-watermark-downloader)

### FAQ

#### How many results can I scrape with TikTok User Search Scraper?

You can set `maxProfilesPerQuery` up to 10,000 and `maxTotalProfiles` up to 50,000. Start with smaller runs because TikTok search result pools vary by query and provider pagination.

#### Can I integrate TikTok User Search Scraper with other apps?

Yes. The actor runs on Apify, so you can use API calls, schedules, webhooks, datasets, Make, Zapier, Google Sheets exports, or downstream enrichment actors.

#### Can I use TikTok User Search Scraper with the Apify API?

Yes. Call `khadinakbar/tiktok-user-search-scraper` with `searchQueries`, then read the default dataset for normalized profile rows and the `RUN_SUMMARY` key for provider and billing diagnostics.

#### Can I use TikTok User Search Scraper through an MCP Server?

Yes. The actor is designed for Apify MCP discovery. It has focused inputs, a compact dataset schema, clear negative scope, and predictable pay-per-profile pricing.

#### Do I need proxies to scrape TikTok users?

No. This actor uses provider APIs for public TikTok user search and does not expose proxy settings to users. Provider keys are configured as actor-owner secrets, not user input.

#### Is it legal to scrape TikTok user data?

This actor is intended for public TikTok profile metadata only. You are responsible for using the data in line with applicable laws, platform terms, privacy rules, and outreach regulations. Do not use scraped public data for spam, harassment, discrimination, or sensitive profiling.

#### Your feedback

If a query returns fewer creators than expected, share the query, expected market, and run ID. TikTok search pools change often, and concrete examples help improve normalization and provider fallback behavior.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this when you want to find TikTok users or creators by keyword, brand, niche, or person name. Accepts one query per line, for example Taylor Swift, beauty creator, or soccer coach. Defaults to the prefilled example for quick testing. Not for scraping videos, comments, followers, or profile feeds.

## `providerOrder` (type: `string`):

Use this to choose which public-data provider is tried first. ScrapeCreators is the recommended primary and SociaVault is the fallback. Defaults to ScrapeCreators first. Not a browser mode and does not use TikTok cookies.

## `maxProfilesPerQuery` (type: `integer`):

Use this to cap how many creator profile rows are saved for each search query. Accepts integers from 1 to 10000. Defaults to 50 and the prefill is 10 for fast tests. This is the main per-query billing guard.

## `maxPagesPerQuery` (type: `integer`):

Use this as a safety cap for provider pagination on each TikTok user search. Accepts integers from 1 to 500. Defaults to 10 and the prefill is 1 for quick checks. Not a result limit by itself.

## `maxTotalProfiles` (type: `integer`):

Use this to cap the whole run across all search queries. Accepts integers from 1 to 50000. Defaults to 5000 and the prefill is 50. This prevents accidental overbilling on large keyword batches.

## `minFollowerCount` (type: `integer`):

Use this to keep only creator profiles at or above a follower threshold. Accepts 0 or any positive integer, for example 10000 for micro-influencer discovery. Defaults to 0, which keeps all returned profiles. This filter is applied after provider search and before billing the saved profile row.

## `verifiedOnly` (type: `boolean`):

Use this when you only want TikTok profiles that are marked verified or have a provider verification label. Defaults to false so discovery is broad. Set true for brand safety, public figures, or official creator research. Not all public profiles expose identical verification metadata across providers.

## `excludePrivateAccounts` (type: `boolean`):

Use this to skip profiles marked private by TikTok or the provider response. Defaults to false because private-account metadata can still help discovery workflows. Set true when you only want public creator candidates. This does not bypass privacy settings or return private content.

## `trim` (type: `boolean`):

Use this to request smaller provider payloads when supported. Defaults to false so profile fields such as bio and verification are preserved. Turn it on only for speed tests where compact profile rows are acceptable. This is not a result filter.

## `includeRawData` (type: `boolean`):

Use this when you need the original provider response attached to each dataset row. It helps debug field drift or build custom parsers. Defaults to false. Not recommended for AI-agent runs because raw payloads are large.

## Actor input object example

```json
{
  "searchQueries": [
    "Taylor Swift"
  ],
  "providerOrder": "scrapecreators-first",
  "maxProfilesPerQuery": 10,
  "maxPagesPerQuery": 1,
  "maxTotalProfiles": 50,
  "minFollowerCount": 0,
  "verifiedOnly": false,
  "excludePrivateAccounts": false,
  "trim": false,
  "includeRawData": false
}
```

# Actor output Schema

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

Normalized TikTok user profile records with handles, profile URLs, bios, follower counts, verification, avatar URLs, and source metadata.

## `runSummary` (type: `string`):

Run-level summary with provider diagnostics, counts, billing counters, filters, and stop reason.

# 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 = {
    "searchQueries": [
        "Taylor Swift"
    ],
    "maxProfilesPerQuery": 10,
    "maxPagesPerQuery": 1,
    "maxTotalProfiles": 50,
    "minFollowerCount": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tiktok-user-search-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 = {
    "searchQueries": ["Taylor Swift"],
    "maxProfilesPerQuery": 10,
    "maxPagesPerQuery": 1,
    "maxTotalProfiles": 50,
    "minFollowerCount": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tiktok-user-search-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 '{
  "searchQueries": [
    "Taylor Swift"
  ],
  "maxProfilesPerQuery": 10,
  "maxPagesPerQuery": 1,
  "maxTotalProfiles": 50,
  "minFollowerCount": 0
}' |
apify call khadinakbar/tiktok-user-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok User Search Scraper - Creator Profiles",
        "description": "Search TikTok users by keyword and extract public creator profiles with handles, bios, follower counts, verification, avatars, and profile URLs. Provider-backed, no cookies, MCP ready.",
        "version": "0.1",
        "x-build-id": "hNgWhLwx9Ov75wZuZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tiktok-user-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tiktok-user-search-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/khadinakbar~tiktok-user-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tiktok-user-search-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/khadinakbar~tiktok-user-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tiktok-user-search-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Use this when you want to find TikTok users or creators by keyword, brand, niche, or person name. Accepts one query per line, for example Taylor Swift, beauty creator, or soccer coach. Defaults to the prefilled example for quick testing. Not for scraping videos, comments, followers, or profile feeds.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providerOrder": {
                        "title": "Provider Order",
                        "enum": [
                            "scrapecreators-first",
                            "sociavault-first",
                            "scrapecreators-only",
                            "sociavault-only"
                        ],
                        "type": "string",
                        "description": "Use this to choose which public-data provider is tried first. ScrapeCreators is the recommended primary and SociaVault is the fallback. Defaults to ScrapeCreators first. Not a browser mode and does not use TikTok cookies.",
                        "default": "scrapecreators-first"
                    },
                    "maxProfilesPerQuery": {
                        "title": "Max Profiles Per Query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Use this to cap how many creator profile rows are saved for each search query. Accepts integers from 1 to 10000. Defaults to 50 and the prefill is 10 for fast tests. This is the main per-query billing guard.",
                        "default": 50
                    },
                    "maxPagesPerQuery": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this as a safety cap for provider pagination on each TikTok user search. Accepts integers from 1 to 500. Defaults to 10 and the prefill is 1 for quick checks. Not a result limit by itself.",
                        "default": 10
                    },
                    "maxTotalProfiles": {
                        "title": "Max Total Profiles",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Use this to cap the whole run across all search queries. Accepts integers from 1 to 50000. Defaults to 5000 and the prefill is 50. This prevents accidental overbilling on large keyword batches.",
                        "default": 5000
                    },
                    "minFollowerCount": {
                        "title": "Minimum Follower Count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Use this to keep only creator profiles at or above a follower threshold. Accepts 0 or any positive integer, for example 10000 for micro-influencer discovery. Defaults to 0, which keeps all returned profiles. This filter is applied after provider search and before billing the saved profile row.",
                        "default": 0
                    },
                    "verifiedOnly": {
                        "title": "Verified Only",
                        "type": "boolean",
                        "description": "Use this when you only want TikTok profiles that are marked verified or have a provider verification label. Defaults to false so discovery is broad. Set true for brand safety, public figures, or official creator research. Not all public profiles expose identical verification metadata across providers.",
                        "default": false
                    },
                    "excludePrivateAccounts": {
                        "title": "Exclude Private Accounts",
                        "type": "boolean",
                        "description": "Use this to skip profiles marked private by TikTok or the provider response. Defaults to false because private-account metadata can still help discovery workflows. Set true when you only want public creator candidates. This does not bypass privacy settings or return private content.",
                        "default": false
                    },
                    "trim": {
                        "title": "Trim Provider Response",
                        "type": "boolean",
                        "description": "Use this to request smaller provider payloads when supported. Defaults to false so profile fields such as bio and verification are preserved. Turn it on only for speed tests where compact profile rows are acceptable. This is not a result filter.",
                        "default": false
                    },
                    "includeRawData": {
                        "title": "Include Raw Provider Data",
                        "type": "boolean",
                        "description": "Use this when you need the original provider response attached to each dataset row. It helps debug field drift or build custom parsers. Defaults to false. Not recommended for AI-agent runs because raw payloads are large.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
