# Tiktok Profile Scraper (`coregent/tiktok-profile-scraper`) Actor

TikTok Profile Scraper extracts public TikTok profile data including bio, followers, following, likes, verification, profile URL, and recent videos. Use it for creator research, influencer discovery, competitor monitoring, lead generation, and analytics.

- **URL**: https://apify.com/coregent/tiktok-profile-scraper.md
- **Developed by:** [Delowar Munna](https://apify.com/coregent) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 24 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 profile results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Profile Scraper

Extract structured TikTok profile data for influencer discovery, creator research, competitor monitoring, lead generation, and analytics workflows.

[![TikTok Profile Scraper](https://raw.githubusercontent.com/coregentdevspace/tiktok-profile-scraper-assets/main/thumbnail-tiktok-profile-scraper.jpg)](https://apify.com/store)

### What does TikTok Profile Scraper do?

**TikTok Profile Scraper** is an Apify Actor that extracts public TikTok profile data from one or many creators. Provide profile URLs, usernames, or search keywords to discover and scrape creators at scale.

For each profile, the scraper returns:
- **Identity** — username, display name, user ID, avatar, verification status
- **Engagement stats** — followers, following, likes, video count
- **Business signals** — bio links, email from bio, Instagram/YouTube handles, business category
- **Contact hints** — boolean flags summarizing available contact signals
- **Recent videos** — video metadata when available in page data
- **Metadata** — timestamps, source type, success/error status

It complements the TikTok scraper suite:
- **TikTok Video Scraper** — deep video-level data
- **TikTok Comment Scraper** — comment extraction
- **TikTok Trend & Discovery Scraper** — trending content discovery

Together they support: **discover trends → inspect videos → inspect comments → inspect creators**

### Why use TikTok Profile Scraper?

- **Find creators by keyword** — discover TikTok profiles in any niche without needing URLs upfront
- **Clean influencer-research output** — structured fields designed for agencies and marketers
- **Contact and business clue extraction** — detect public email patterns, external links, and linked social handles
- **Batch-friendly structure** — designed for spreadsheets, BI tools, CRM imports, and AI pipelines
- **Traceable and normalized data** — includes input echo, timestamps, and consistent field naming

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `profiles` | string[] | `[]` | TikTok profile URLs or usernames |
| `searchKeywords` | string[] | `[]` | Keywords to search for TikTok user profiles |
| `resultsPerKeyword` | integer | `10` | Max profiles to scrape per search keyword (1–100) |
| `includeRecentVideos` | boolean | `true` | Include recent video data when available |
| `maxRecentVideos` | integer | `12` | Number of recent videos to inspect per profile (1–30) |
| `includePinnedVideos` | boolean | `true` | Identify pinned videos when visible |
| `includeBusinessLinks` | boolean | `true` | Extract external links and linked accounts |
| `includeContactHints` | boolean | `true` | Infer contact/business clues from bio text |
| `proxyConfiguration` | object | — | Apify proxy configuration (residential recommended) |

You can use `profiles` and `searchKeywords` together or separately. At least one must be provided.

#### Accepted profile formats

- Full URL: `https://www.tiktok.com/@examplecreator`
- With @: `@examplecreator`
- Username only: `examplecreator`

Duplicates are automatically removed before processing.

#### Sample input: Scrape profiles directly

```json
{
  "profiles": [
    "https://www.tiktok.com/@tesla.flex",
    "@jeremyjudkins2",
    "teslatheband"
  ],
  "includeRecentVideos": true,
  "maxRecentVideos": 12,
  "includeBusinessLinks": true,
  "includeContactHints": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Sample input: Discover profiles by keyword

```json
{
  "searchKeywords": ["tesla", "fitness coach"],
  "resultsPerKeyword": 20,
  "includeRecentVideos": true,
  "maxRecentVideos": 6,
  "includeBusinessLinks": true,
  "includeContactHints": true
}
```

### Output

Each output item represents **one TikTok profile**. Results are available in JSON, CSV, Excel, and through three dataset views in the Apify console.

![TikTok Profile Scraper — Profiles table view](https://raw.githubusercontent.com/coregentdevspace/tiktok-profile-scraper-assets/main/tiktok-profile-scraper-output-profiles-table-view.png)

#### Output tab: Profiles

The **Profiles** view shows identity, stats, and verification status at a glance.

```json
{
  "username": "tesla.flex",
  "nickname": "Brandon | Tesla Flex",
  "profileUrl": "https://www.tiktok.com/@tesla.flex",
  "verified": false,
  "privateAccount": false,
  "followerCount": 3000000,
  "followingCount": 593,
  "likesCount": 159700000,
  "videoCount": 2916,
  "signature": "⚡️Founder of TeslaTok⚡️\n⬇️Tesla Accessories & More⬇️",
  "bioLink": "link.me/brandon",
  "isBusinessLike": true,
  "scrapedAt": "2026-03-16T04:20:50.018Z",
  "success": true
}
```

#### Output tab: Contact & Business

The **Contact & Business** view focuses on business signals, email, social handles, and contact clues — ideal for lead generation and outreach.

```json
{
  "username": "itsbennyblanco",
  "nickname": "benny blanco",
  "verified": true,
  "signature": "i know u r wondering why i'm verified\ninquiries - bennyblancoinfo@icloud.com",
  "bioLink": "https://lnk.to/friendskeepsecrets",
  "bioEmail": "bennyblancoinfo@icloud.com",
  "instagramHandle": null,
  "youtubeChannel": null,
  "businessCategory": null,
  "isBusinessLike": true,
  "contactHints": {
    "hasEmailInBio": true,
    "hasExternalLink": true,
    "hasInstagram": false,
    "hasYouTube": false
  },
  "followerCount": 8500000,
  "likesCount": 304300000
}
```

#### Output tab: Recent Videos

The **Recent Videos** view shows recent video metadata when available in TikTok's page data.

```json
{
  "username": "jeremyjudkins2",
  "nickname": "Jeremy Judkins",
  "followerCount": 238000,
  "videoCount": 4326,
  "recentVideos": []
}
```

> **Note:** TikTok currently loads video data via a signed API call that requires browser-generated tokens. The `recentVideos` array may be empty when video data is not included in the page source. Profile metadata and stats are always extracted.

#### Full output example (all fields)

```json
{
  "input": "@the_golden_tesla",
  "username": "the_golden_tesla",
  "profileUrl": "https://www.tiktok.com/@the_golden_tesla",
  "userId": "6776639922013406213",
  "secUid": "MS4wLjABAAAA5SIGjZAamxjcC7nRbxzBpKlTXYVb5BlE9YV-cVqtkVd-hp5opp_CuW4MrXUb7yYu",
  "nickname": "The Golden Tesla",
  "signature": "Thegoldentesla@gmail.com\n⬇️ CHECK THIS ⬇️",
  "avatarUrl": "https://p16-common-sign.tiktokcdn-us.com/tos-maliva-avt-0068/bde603046bacefd1eb283d00b7d552ee~tplv-tiktokx-cropcenter:1080:1080.jpeg",
  "verified": false,
  "privateAccount": false,
  "language": "en",
  "followerCount": 2100000,
  "followingCount": 330,
  "likesCount": 37000000,
  "videoCount": 915,
  "friendCount": 126,
  "bioLink": "https://beacons.ai/the_golden_tesla",
  "bioEmail": "Thegoldentesla@gmail.com",
  "instagramHandle": null,
  "youtubeChannel": null,
  "businessCategory": null,
  "isBusinessLike": true,
  "accountCreatedAt": "2020-04-24T02:40:38.000Z",
  "recentVideos": [],
  "contactHints": {
    "hasEmailInBio": true,
    "hasExternalLink": true,
    "hasInstagram": false,
    "hasYouTube": false
  },
  "scrapedAt": "2026-03-16T04:20:50.135Z",
  "sourceType": "search",
  "success": true
}
```

#### Error output example

When a profile cannot be found or extracted, the actor returns a structured error record:

```json
{
  "input": "@nonexistentprofile",
  "success": false,
  "error": "Profile not found",
  "sourceType": "username",
  "scrapedAt": "2026-03-16T04:21:00.000Z"
}
```

#### Output fields reference

##### Identity and profile

| Field | Type | Description |
|-------|------|-------------|
| `input` | string | The original input (URL, username, or @handle) |
| `username` | string | TikTok unique username |
| `profileUrl` | string | Canonical profile URL |
| `userId` | string | Numeric TikTok user ID |
| `secUid` | string | TikTok security user ID |
| `nickname` | string | Display name |
| `signature` | string | Bio text |
| `avatarUrl` | string | Profile image URL |
| `verified` | boolean | Blue check verification status |
| `privateAccount` | boolean | Whether the account is private |
| `language` | string | Profile language code |

##### Public counters

| Field | Type | Description |
|-------|------|-------------|
| `followerCount` | number | Number of followers |
| `followingCount` | number | Number of accounts following |
| `likesCount` | number | Total likes received across all videos |
| `videoCount` | number | Number of videos posted |
| `friendCount` | number | Mutual follower count (when available) |

##### Business and contact signals

| Field | Type | Description |
|-------|------|-------------|
| `bioLink` | string | External website URL from profile |
| `bioEmail` | string | Email address extracted from bio text |
| `instagramHandle` | string | Instagram handle from linked accounts or bio |
| `youtubeChannel` | string | YouTube channel from linked accounts or bio |
| `businessCategory` | string | TikTok business category (e.g., "Automotive & Transportation") |
| `isBusinessLike` | boolean | Inferred business/creator account flag |
| `contactHints` | object | Summary flags: `hasEmailInBio`, `hasExternalLink`, `hasInstagram`, `hasYouTube` |

##### Content and metadata

| Field | Type | Description |
|-------|------|-------------|
| `accountCreatedAt` | string | Account creation date (ISO 8601, when available) |
| `recentVideos` | array | Recent video objects with stats (when available in page data) |
| `scrapedAt` | string | Extraction timestamp (ISO 8601) |
| `sourceType` | string | How the profile was provided: `"url"`, `"username"`, or `"search"` |
| `success` | boolean | Whether extraction succeeded |
| `error` | string | Error message (only present on failed items) |

### How keyword search works

When you provide `searchKeywords`, the scraper discovers TikTok profiles by querying multiple external search engines in parallel:

1. **Startpage** and **Brave Search** are used as primary engines (most reliable)
2. **DuckDuckGo**, **Google**, and **Bing** are included as best-effort supplemental sources
3. Queries run in up to 3 batches with early termination — stops as soon as enough profiles are found
4. Results from all engines are merged and deduplicated by username
5. Discovered profiles are then scraped for full profile data

Each keyword can return up to `resultsPerKeyword` profiles (default 10, max 100).

### Use cases

- **Influencer discovery** — find creators in any niche by keyword, extract profiles for campaign research
- **Competitor monitoring** — track competing brand or creator accounts over time
- **Lead generation** — collect bios, external links, emails, and business contact clues at scale
- **Creator database building** — build structured datasets for outreach, analytics, or CRM import
- **Trend follow-up** — after discovering trending content, inspect the creators behind it
- **AI enrichment** — feed creator data into classification, scoring, or summarization pipelines

### Tips and best practices

- **Start small** — test with 2–3 profiles or a single keyword first to verify output format
- **Mix input modes** — use URLs, @handles, and keywords in the same run
- **Use with other actors** — discover trending creators with TikTok Trend & Discovery Scraper, then feed their usernames here for full profile data
- **Schedule for monitoring** — run on a schedule to track creator growth over time
- **Enable contact hints** — the `contactHints` object provides quick boolean flags useful for filtering leads

### Proxy configuration

Residential proxies are recommended for reliable TikTok scraping, especially for larger batches.

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

The scraper works without proxies for small batches and keyword search, but may encounter rate limiting on larger runs.

### Integrations

Connect TikTok Profile Scraper to your existing tools and workflows:

- **Google Sheets** — export profile data directly to spreadsheets
- **Slack / Email** — get notifications when scraping runs complete
- **Webhooks** — trigger downstream workflows automatically
- **Apify API** — access results programmatically for custom integrations
- **Other actors** — combine with TikTok Video Scraper, Comment Scraper, and Trend & Discovery Scraper for full-funnel creator intelligence

### FAQ

**How many profiles can I scrape in one run?**
There is no hard limit. Small batches (10–50) run reliably. Larger batches depend on proxy quality and TikTok's rate limiting.

**How does keyword search find profiles?**
The scraper queries external search engines (Startpage, Brave, DuckDuckGo, Google, Bing) for TikTok profile pages matching your keyword. It merges and deduplicates results across all engines, then scrapes each discovered profile for full data.

**Why is `recentVideos` empty?**
TikTok currently loads video data via a signed API call that requires browser-generated tokens. Profile metadata, stats, and business signals are always extracted from the page source. Video data will populate automatically if TikTok restores it to the page source.

**Why are some fields null?**
Fields like `businessCategory`, `friendCount`, `bioEmail`, and `instagramHandle` depend on what the creator has configured and what TikTok includes in its page data. They are extracted on a best-effort basis.

**What if a profile is not found?**
The actor returns a record with `success: false` and a descriptive error message. Other profiles in the batch continue processing normally. Profiles discovered via keyword search that return 404 are silently skipped.

**Does this work for private accounts?**
Private accounts return limited data (username, nickname, verification status). Most counters and content fields will not be available.

**Can I use this without proxies?**
Yes. The scraper works without proxies for small batches and keyword search. For larger runs or more consistent results, residential proxies are recommended.

# Actor input Schema

## `profiles` (type: `array`):

TikTok profile URLs or usernames. Example: https://www.tiktok.com/@examplecreator, @anothercreator, thirdcreator

## `searchKeywords` (type: `array`):

Keywords to search for TikTok user profiles. The scraper will find matching profiles and extract their data. Example: fitness coach, beauty brand

## `resultsPerKeyword` (type: `integer`):

Maximum number of profiles to scrape per search keyword.

## `includeRecentVideos` (type: `boolean`):

Include recent video summaries for each profile.

## `maxRecentVideos` (type: `integer`):

Number of recent videos to inspect per profile (used for recentVideos and recentVideosSummary).

## `includePinnedVideos` (type: `boolean`):

Identify pinned videos when visible in the recent videos list.

## `includeBusinessLinks` (type: `boolean`):

Extract external links and linked social accounts from the profile.

## `includeContactHints` (type: `boolean`):

Infer contact and business clues from the bio text (email patterns, social handles, etc.).

## `proxyConfiguration` (type: `object`):

Apify proxy configuration. Residential proxies recommended for TikTok.

## Actor input object example

```json
{
  "profiles": [],
  "searchKeywords": [],
  "resultsPerKeyword": 10,
  "includeRecentVideos": true,
  "maxRecentVideos": 12,
  "includePinnedVideos": true,
  "includeBusinessLinks": true,
  "includeContactHints": true
}
```

# Actor output Schema

## `profiles` (type: `string`):

No description

## `contact` (type: `string`):

No description

## `recentVideos` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/tiktok-profile-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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Profile Scraper",
        "description": "TikTok Profile Scraper extracts public TikTok profile data including bio, followers, following, likes, verification, profile URL, and recent videos. Use it for creator research, influencer discovery, competitor monitoring, lead generation, and analytics.",
        "version": "0.1",
        "x-build-id": "R8uBCdQcCmraiZ9Gd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coregent~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coregent-tiktok-profile-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/coregent~tiktok-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-coregent-tiktok-profile-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/coregent~tiktok-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-coregent-tiktok-profile-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",
                "properties": {
                    "profiles": {
                        "title": "Profiles",
                        "type": "array",
                        "description": "TikTok profile URLs or usernames. Example: https://www.tiktok.com/@examplecreator, @anothercreator, thirdcreator",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "searchKeywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for TikTok user profiles. The scraper will find matching profiles and extract their data. Example: fitness coach, beauty brand",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "resultsPerKeyword": {
                        "title": "Results Per Keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of profiles to scrape per search keyword.",
                        "default": 10
                    },
                    "includeRecentVideos": {
                        "title": "Include Recent Videos",
                        "type": "boolean",
                        "description": "Include recent video summaries for each profile.",
                        "default": true
                    },
                    "maxRecentVideos": {
                        "title": "Max Recent Videos",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of recent videos to inspect per profile (used for recentVideos and recentVideosSummary).",
                        "default": 12
                    },
                    "includePinnedVideos": {
                        "title": "Include Pinned Videos",
                        "type": "boolean",
                        "description": "Identify pinned videos when visible in the recent videos list.",
                        "default": true
                    },
                    "includeBusinessLinks": {
                        "title": "Include Business Links",
                        "type": "boolean",
                        "description": "Extract external links and linked social accounts from the profile.",
                        "default": true
                    },
                    "includeContactHints": {
                        "title": "Include Contact Hints",
                        "type": "boolean",
                        "description": "Infer contact and business clues from the bio text (email patterns, social handles, etc.).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Residential proxies recommended for TikTok."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```