# TikTok Scraper ($0.2 per 1000 results) (`igolaizola/tiktok-scraper`) Actor

$0.2/1K 💸 Scrape TikTok videos, profiles, hashtags, and search queries from URLs or keywords. Extract captions, authors, music, media links, engagement metrics, and user data for influencer research, lead generation, market analysis, and AI workflows. Export JSON/CSV or use the API.

- **URL**: https://apify.com/igolaizola/tiktok-scraper.md
- **Developed by:** [Iñigo Garcia Olaizola](https://apify.com/igolaizola) (community)
- **Categories:** Social media, Videos, Lead generation
- **Stats:** 14 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.18 / 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.
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 Scraper — Videos, Profiles, Hashtags & Search Results

Extract public TikTok videos from video URLs, creator profiles, hashtags, and keyword searches. This TikTok scraper returns structured video data for trend research, influencer discovery, content monitoring, lead enrichment, and social media analysis.

### 🤖 What does TikTok Scraper do?

TikTok Scraper helps you scrape public TikTok video data without dealing with manual collection. You can combine direct video links with profile, hashtag, and search-based discovery in the same run, then export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

- **Video URLs** — resolve known TikTok links into clean video records
- **Profiles** — collect recent or popular videos from public creator accounts
- **Hashtags** — monitor videos published under a topic or trend
- **Search queries** — discover videos for keywords, niches, brands, or topics
- **Structured output** — get captions, authors, music info, media links, and engagement metrics

**Great for:** social listening, influencer research, competitor tracking, content discovery, AI datasets, and market research.

> SEO keywords: **TikTok scraper**, **scrape TikTok videos**, **TikTok profile scraper**, **TikTok hashtag scraper**, **TikTok search scraper**, **TikTok API alternative**, **Apify actor**.

### 💡 Why use TikTok Scraper?

- 📈 **Track trends early** — monitor hashtags and search terms to spot rising topics and formats
- 🎯 **Research creators** — collect videos from public profiles for influencer vetting and benchmarking
- 🔎 **Validate specific videos** — turn direct TikTok video URLs into structured records you can store or analyze
- 🧠 **Build reusable datasets** — export clean video-level rows for dashboards, BI tools, enrichment, or AI workflows

### 🚀 How to use

1. **Add your sources** — fill in one or more of `videoUrls`, `profiles`, `hashtags`, or `searchQueries`.
2. **Set your limits** — use `maxVideosPerInput` to limit each profile, hashtag, or search query, and `maxTotalVideos` to cap the whole run.
3. **Choose profile options** — if you scrape profiles, optionally set `profileVideoSort`, `profileScrapeSections`, and profile date filters.
4. **Run the actor** — click **Run** in Apify.
5. **Download the dataset** — export results from the **Dataset** tab or use them through the Apify API.

### 📝 Input Parameters

| Parameter | Type | Required | Description |
| --------- | ---- | -------- | ----------- |
| `profiles` | Array[String] | No* | TikTok usernames or profile URLs to scrape, such as `"tiktok"` or `"https://www.tiktok.com/@apify"`. |
| `hashtags` | Array[String] | No* | TikTok hashtags or hashtag URLs to scrape, such as `"health"` or `"#metabolichealth"`. |
| `searchQueries` | Array[String] | No* | TikTok keyword searches to scrape, such as `"metabolic health"` or `"running tips"`. |
| `videoUrls` | Array[String] | No* | Direct TikTok video URLs. Each URL returns one video row when the video is public and available. |
| `maxTotalVideos` | Integer | No | Maximum number of video rows to save across the whole run. Use `0` to keep all fetched videos. Default `0`. |
| `maxVideosPerInput` | Integer | No | Maximum number of recent public videos to collect for each profile, hashtag, or search query. Video URLs always return one row each. Use `0` for no per-input limit. Default `0`. |
| `profileVideoSort` | Enum | No | Sort mode for profile videos: `"latest"` or `"popular"`. Default `"latest"`. |
| `profileScrapeSections` | Array[String] | No | Profile sections to scrape: `"videos"` · `"reposts"`. Default `["videos"]`. |
| `videosPublishedBeforeDate` | String | No | For latest profile videos, start before this date. Use `YYYY-MM-DD` or RFC3339. |
| `videosPublishedAfterDate` | String | No | For profile videos, stop once older videos are reached. Use `YYYY-MM-DD` or `RFC3339`. This works with latest profile videos. |

\* Provide at least one of `profiles`, `hashtags`, `searchQueries`, or `videoUrls`.

#### Example inputs

**Mixed TikTok discovery**

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@tiktok/video/7460937381265411370"
  ],
  "profiles": [
    "tiktok",
    "https://www.tiktok.com/@apify"
  ],
  "hashtags": [
    "health",
    "#metabolichealth"
  ],
  "searchQueries": [
    "metabolic health"
  ],
  "maxTotalVideos": 100,
  "maxVideosPerInput": 20,
  "profileVideoSort": "latest",
  "profileScrapeSections": [
    "videos"
  ]
}
````

**Profile research with reposts and date filtering**

```json
{
  "profiles": [
    "nike"
  ],
  "maxTotalVideos": 80,
  "maxVideosPerInput": 40,
  "profileVideoSort": "latest",
  "profileScrapeSections": [
    "videos",
    "reposts"
  ],
  "videosPublishedBeforeDate": "2026-01-01",
  "videosPublishedAfterDate": "2025-01-01"
}
```

**Hashtag and keyword monitoring**

```json
{
  "hashtags": [
    "skincare",
    "running"
  ],
  "searchQueries": [
    "marathon training",
    "morning routine"
  ],
  "maxTotalVideos": 120,
  "maxVideosPerInput": 30
}
```

### 📊 Output

Each dataset item represents one TikTok video. Source context is repeated on every row so you can filter, sort, and join the dataset easily after export.

#### Field reference

- **`id`** *(string)* — TikTok video ID
- **`input`** *(string)* — normalized source value that produced the row
- **`inputType`** *(string)* — source type: profile, hashtag, search, or video
- **`profile`** *(string)* — profile username when the row came from a profile input
- **`profileSection`** *(string)* — profile section such as `videos` or `reposts`
- **`hashtag`** *(string)* — hashtag source when applicable
- **`searchQuery`** *(string)* — keyword query when applicable
- **`videoUrl`** *(string)* — original video URL input when applicable
- **`text`** *(string)* — video caption or text
- **`webVideoUrl`** *(string)* — TikTok video page URL
- **`createTime`** *(number)* — video creation timestamp
- **`createTimeISO`** *(string)* — ISO timestamp version of the creation time
- **`duration`** *(number)* — video duration in seconds
- **`region`** *(string)* — region code when available
- **`playCount`** *(number)* — view count
- **`diggCount`** *(number)* — like count
- **`commentCount`** *(number)* — comment count
- **`shareCount`** *(number)* — share count
- **`collectCount`** *(number)* — collect or favorite count
- **`downloadCount`** *(number)* — download count
- **`mediaUrls`** *(array)* — media download URLs when available
- **`authorMeta`** *(object)* — author ID, username, and nickname
- **`musicMeta`** *(object)* — music title, author, and play URL
- **`videoMeta`** *(object)* — media and cover URLs, including watermarked playback when available
- **`profileMeta`** *(object)* — profile metadata attached to profile-sourced rows when available

#### Example output

```json
{
  "id": "7653043871131143437",
  "input": "tiktok",
  "inputType": "profile",
  "profile": "tiktok",
  "profileSection": "videos",
  "text": "Video caption text...",
  "webVideoUrl": "https://www.tiktok.com/@tiktok/video/7653043871131143437",
  "createTime": 1781863210,
  "createTimeISO": "2026-06-19T10:00:10Z",
  "duration": 42,
  "region": "US",
  "playCount": 104,
  "diggCount": 8,
  "commentCount": 1,
  "shareCount": 0,
  "collectCount": 0,
  "downloadCount": 0,
  "mediaUrls": [
    "https://example-cdn.com/video.mp4"
  ],
  "authorMeta": {
    "id": "107955",
    "name": "tiktok",
    "nickName": "TikTok"
  },
  "musicMeta": {
    "musicName": "original sound - tiktok",
    "musicAuthor": "TikTok",
    "playUrl": "https://example-cdn.com/music.mp3"
  },
  "videoMeta": {
    "duration": 42,
    "playUrl": "https://example-cdn.com/video.mp4",
    "coverUrl": "https://example-cdn.com/cover.jpeg"
  },
  "profileMeta": {
    "id": "107955",
    "username": "tiktok",
    "nickname": "TikTok",
    "url": "https://www.tiktok.com/@tiktok",
    "followerCount": 12345,
    "videoCount": 410
  }
}
```

### 🧭 Tips

- **Direct video lookups:** use `videoUrls` when you already know the exact TikTok links you want.
- **Broad trend monitoring:** combine `hashtags` and `searchQueries` in one run to compare topic-driven discovery with keyword-driven discovery.
- **Unlimited collection:** set `maxVideosPerInput` to `0` when you want to keep collecting until no more public videos are available.
- **Global cap:** use `maxTotalVideos` to keep large mixed-source runs predictable.
- **Profile archive windows:** combine `videosPublishedBeforeDate` and `videosPublishedAfterDate` to focus profile scraping on a specific publication period.

### ⚙️ Best Practices

- This actor works with **public TikTok data** only. Private, deleted, restricted, or unavailable content may return partial data or no result.
- `videosPublishedBeforeDate` and `videosPublishedAfterDate` apply to **profile video collection**, not direct video URLs, hashtags, or search queries.
- Media links can expire over time. If you need long-term retention, store downloaded assets in your own storage after the run.
- For the cleanest analysis, run separate jobs for very different goals, such as one run for creator research and another for hashtag monitoring.

### ⚖️ Legal & Ethical Considerations

- **Respect TikTok's Terms of Service** and use the actor responsibly.
- **Handle personal data carefully** and comply with applicable privacy laws such as GDPR or CCPA.
- **Avoid misuse** of scraped data for spam, harassment, or deceptive practices.
- **Review local laws and platform rules** before using data in commercial or regulated workflows.

This actor is an independent tool and is **not** affiliated with, endorsed by, or sponsored by TikTok. All trademarks are the property of their respective owners.

### ❓ FAQ

**Can I combine profiles, hashtags, search queries, and video URLs in one run?**
Yes. You can use any combination of those inputs, and the actor will save one dataset row per video.

**What happens when I set `maxVideosPerInput` to `0`?**
The actor keeps collecting videos for each profile, hashtag, or search query until no more public results are available.

**Does `maxTotalVideos` apply across all sources?**
Yes. It limits the total number of saved video rows across video URLs, profiles, hashtags, and search queries.

**Do date filters work for hashtags and search queries?**
No. `videosPublishedBeforeDate` and `videosPublishedAfterDate` are for profile video collection.

**Can I scrape reposts from TikTok profiles?**
Yes. Add `"reposts"` to `profileScrapeSections` if you want reposted videos in addition to standard profile videos.

### 🛟 Support

Need a custom field or export?
Open an issue or contact me at https://igolaizola.com/#contact

# Actor input Schema

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

TikTok usernames or profile URLs to scrape videos from.

## `hashtags` (type: `array`):

TikTok hashtags or hashtag URLs to scrape videos from.

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

TikTok video search queries to scrape.

## `videoUrls` (type: `array`):

TikTok video URLs to scrape directly. Each URL produces one video row when the video is public and available.

## `maxTotalVideos` (type: `integer`):

Maximum number of video rows to save across video URLs, profiles, hashtags, and search queries. Use 0 to save all fetched videos.

## `maxVideosPerInput` (type: `integer`):

Maximum number of recent public videos to include for each profile, hashtag, or search query. Video URL inputs always resolve one video per URL. Use 0 to keep paging until there are no more videos.

## `profileVideoSort` (type: `string`):

Sort mode for profile videos.

## `profileScrapeSections` (type: `array`):

Profile sections to scrape. Supported values: videos, reposts.

## `videosPublishedBeforeDate` (type: `string`):

For latest profile videos, start fetching videos published before this date. Use YYYY-MM-DD or RFC3339.

## `videosPublishedAfterDate` (type: `string`):

For profile videos, force latest sorting and stop pagination once videos older than this date are reached. Use YYYY-MM-DD or RFC3339.

## Actor input object example

```json
{
  "profiles": [
    "tiktok"
  ],
  "maxTotalVideos": 100,
  "maxVideosPerInput": 0,
  "profileVideoSort": "latest",
  "profileScrapeSections": [
    "videos"
  ]
}
```

# Actor output Schema

## `results` (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 = {
    "profiles": [
        "tiktok"
    ],
    "maxTotalVideos": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("igolaizola/tiktok-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 = {
    "profiles": ["tiktok"],
    "maxTotalVideos": 100,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Scraper ($0.2 per 1000 results)",
        "description": "$0.2/1K 💸 Scrape TikTok videos, profiles, hashtags, and search queries from URLs or keywords. Extract captions, authors, music, media links, engagement metrics, and user data for influencer research, lead generation, market analysis, and AI workflows. Export JSON/CSV or use the API.",
        "version": "0.0",
        "x-build-id": "VOJT3DlY6cYDujhoS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igolaizola~tiktok-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igolaizola-tiktok-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/igolaizola~tiktok-scraper/runs": {
            "post": {
                "operationId": "runs-sync-igolaizola-tiktok-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/igolaizola~tiktok-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-igolaizola-tiktok-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": "TikTok profiles",
                        "type": "array",
                        "description": "TikTok usernames or profile URLs to scrape videos from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hashtags": {
                        "title": "TikTok hashtags",
                        "type": "array",
                        "description": "TikTok hashtags or hashtag URLs to scrape videos from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "TikTok video search queries to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "TikTok video URLs to scrape directly. Each URL produces one video row when the video is public and available.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTotalVideos": {
                        "title": "Max total videos",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of video rows to save across video URLs, profiles, hashtags, and search queries. Use 0 to save all fetched videos.",
                        "default": 0
                    },
                    "maxVideosPerInput": {
                        "title": "Max videos per input",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of recent public videos to include for each profile, hashtag, or search query. Video URL inputs always resolve one video per URL. Use 0 to keep paging until there are no more videos.",
                        "default": 0
                    },
                    "profileVideoSort": {
                        "title": "Profile video sort",
                        "enum": [
                            "latest",
                            "popular"
                        ],
                        "type": "string",
                        "description": "Sort mode for profile videos.",
                        "default": "latest"
                    },
                    "profileScrapeSections": {
                        "title": "Profile sections",
                        "type": "array",
                        "description": "Profile sections to scrape. Supported values: videos, reposts.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "videos",
                                "reposts"
                            ],
                            "enumTitles": [
                                "Videos",
                                "Reposts"
                            ]
                        },
                        "default": [
                            "videos"
                        ]
                    },
                    "videosPublishedBeforeDate": {
                        "title": "Published before date",
                        "type": "string",
                        "description": "For latest profile videos, start fetching videos published before this date. Use YYYY-MM-DD or RFC3339."
                    },
                    "videosPublishedAfterDate": {
                        "title": "Published after date",
                        "type": "string",
                        "description": "For profile videos, force latest sorting and stop pagination once videos older than this date are reached. Use YYYY-MM-DD or RFC3339."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```