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

🎬 TikTok Video Scraper extracts video metadata at scale—captions, hashtags, views, likes, comments, shares, author & audio details, publish date & URLs. 📊 Perfect for trend analysis, competitor research, influencer discovery & content strategy. CSV/JSON-ready.

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

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Tiktok Video Scraper

Tiktok Video Scraper is a production-ready tiktok video scraper tool that extracts structured metadata from public TikTok video URLs—captions, hashtags, views, likes, comments, shares, authors, audio details, publish timestamps, and canonical URLs. It solves the manual, error-prone process of copy-pasting by turning each TikTok post into clean, analytics-ready records. Built for marketers, developers, data analysts, and researchers, this tiktok data scraper enables scalable trend tracking, competitor insights, and automated reporting—so you can scrape tiktok videos in bulk and act on real-time signals.

### What data / output can you get?

Below are real output fields produced by the actor. Values are normalized for analytics and exportable to CSV, JSON, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| id | Unique TikTok video ID | "7356123456789012345" |
| text | Video caption/description | "Trying the new recipe challenge! #foodtok" |
| textLanguage | Detected language of text | "en" |
| createTimeISO | Publish timestamp in ISO format | "2026-03-10T14:22:15.000Z" |
| locationCreated | Location or country code if available | "US" |
| isAd | Whether the post is marked as an ad | false |
| authorMeta.name | Author’s username (uniqueId) | "apifyoffice" |
| authorMeta.verified | Author verification status | true |
| musicMeta.musicName | Music title used in the post | "original sound" |
| videoMeta.duration | Video length in seconds | 15 |
| playCount | Number of views | 1234500 |
| webVideoUrl | Canonical TikTok video URL | "https://www.tiktok.com/@apifyoffice/video/7200360993149553925" |

Notes:
- Engagement metrics also include diggCount (likes), shareCount, commentCount, collectCount, and repostCount.
- Rich nested metadata is provided for authorMeta, musicMeta, and videoMeta, including avatars, verification, followers, audio play URL, cover images, dimensions, and subtitle links.
- Hashtags are returned with id/name/title/cover when available.
- Results can be downloaded from the Apify dataset in CSV, JSON, or Excel formats.

### Key features

- ⚡️ Bold accuracy on public pages  
  Extracts structured, field-level metadata (captions, hashtags, engagement stats, author and music details) directly from public video pages using resilient parsing and a headless browser for backup.

- 📈 Batch scraping & bulk automation  
  Paste multiple post URLs to scrape tiktok videos in bulk. Optionally fetch related videos for each post to expand datasets with minimal input.

- 🔎 Related video discovery  
  Enable “Scrape related videos” to collect additional content for each seed post. Fine-tune volume with resultsPerPage; the actor respects TikTok’s typical 12–16 related video limit.

- 🧩 Clean, nested JSON output  
  Consistent schema with authorMeta, musicMeta, videoMeta, and normalized engagement fields—ready for BI dashboards, modeling, or downstream pipelines.

- 💾 Flexible exports  
  Export results from the Apify dataset as CSV, JSON, or Excel for analysis, enrichment, or warehousing.

- 👩‍💻 Developer friendly  
  Run via Apify API or integrate into Python/SDK-based workflows. Ideal for building a tiktok api scraper pipeline or tiktok crawler in a data stack.

- 🧠 Production-ready reliability  
  Async fetching + Playwright-backed fallbacks with retry logic ensure high success rates at scale.

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

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

2. Open the actor and prepare your inputs  
   You’ll provide TikTok post URLs and optional settings for related videos.

3. Add post URLs  
   In the “Direct URL(s) for scraping specific video(s)” field, paste one or more TikTok video links. The editor accepts a list (string list).

4. (Optional) Enable related videos  
   Toggle “Scrape related videos” to discover additional videos for each provided post URL.

5. (Optional) Set resultsPerPage  
   Define “Number of related videos per post.” This only applies when related videos are enabled. The actor respects typical platform limits (12–16 related videos per post).

6. Start the run  
   Click Start. The actor will fetch each video, normalize metadata, and (if enabled) append related videos to your results.

7. Download your data  
   Open the run’s dataset to export results in CSV, JSON, or Excel and plug them into your analytics or enrichment workflows.

Pro tip: Use related video scraping to quickly grow datasets for hashtag analysis or content benchmarking—great for a lightweight tiktok trending videos scraper workflow.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing trend analysis | Track formats, captions, and sounds that drive views; quantify engagement to guide content strategy. |
| Influencer benchmarking | Evaluate creators by likes, shares, comments, and audience signals (verification, followers). |
| Hashtag performance insights | Analyze hashtags returned per post to map communities and content clusters. |
| Competitor campaign monitoring | Monitor public creative, music usage, and engagement to benchmark campaign outcomes. |
| Data engineering API pipeline | Feed normalized JSON into a warehouse or ML model as a tiktok api scraper component. |
| Academic & behavioral research | Study posting patterns, durations, and engagement dynamics across public datasets. |
| Social listening (public posts) | Combine captions and hashtags to understand themes that resonate in your niche. |

### Why choose Tiktok Video Scraper?

Tiktok Video Scraper is built for precision, automation, and scale—turning public TikTok posts into clean, analytics-ready data with minimal setup.

- ✅ Accurate, structured fields: Consistent schema for authorMeta, musicMeta, videoMeta, and engagement metrics.
- 🌍 Public-only, no login: Scrapes publicly available TikTok pages—no authentication flows required.
- 🚀 Scales with your workload: Batch multiple URLs and optionally expand with related videos to grow coverage fast.
- 👩‍💻 Developer access: Control runs via the Apify API; ideal for pipelines that need a dependable tiktok data extraction tool.
- 🔒 Ethical by design: Focused on public content only, suitable for compliant, research-backed use cases.
- 💾 Easy exports & interoperability: Download as CSV/JSON/Excel from the dataset for BI and analytics.
- 🧱 More reliable than extensions: Runs on server-grade infrastructure with headless browser fallbacks and retries.

In short: a robust tiktok web scraper for teams who need repeatable, structured outputs rather than unreliable, ad-hoc tools.

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

Yes—when done responsibly. This actor targets public TikTok video pages and extracts publicly visible metadata (e.g., captions, hashtags, engagement numbers, authors, and music details). It does not access private profiles, DMs, or login-gated content.

Guidelines for compliant use:
- Only collect and process public data.
- Respect TikTok’s terms and applicable laws (GDPR, CCPA).
- Avoid storing or using personal data in ways that violate privacy regulations.
- Consult your legal team for jurisdiction-specific requirements and edge cases.

### Input parameters & output format

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

Parameters

- postURLs (array, required)\
  Direct URL(s) for scraping specific video(s). You can enter URLs one by one, or upload/link to a text file. Default: none.

- scrapeRelatedVideos (boolean, optional)\
  Tick to scrape related videos for each provided post URL. The maximum number of related videos is governed by resultsPerPage. Default: false.

- resultsPerPage (integer, optional)\
  Number of related videos per post. Applies only when scrapeRelatedVideos is enabled. Minimum: 1, Maximum: 1,000,000. Default: 10.

#### Example JSON output

```json
{
  "id": "7200360993149553925",
  "text": "Behind the scenes at the office! #buildinpublic",
  "textLanguage": "en",
  "createTime": 1710176535,
  "createTimeISO": "2024-03-11T12:22:15.000Z",
  "locationCreated": "US",
  "isAd": false,
  "authorMeta": {
    "id": "67584930211223344",
    "name": "apifyoffice",
    "profileUrl": "https://www.tiktok.com/@apifyoffice",
    "nickName": "Apify",
    "verified": true,
    "signature": "Automation for the web",
    "bioLink": null,
    "originalAvatarUrl": "https://p16-sign-va.tiktokcdn.com/avatarLarge.jpg",
    "avatar": "https://p16-sign-va.tiktokcdn.com/avatarMedium.jpg",
    "privateAccount": false,
    "roomId": "",
    "ttSeller": false,
    "followDatasetUrl": null,
    "following": 120,
    "friends": 25,
    "fans": 15000,
    "heart": 250000,
    "video": 320,
    "digg": 0
  },
  "musicMeta": {
    "musicName": "original sound",
    "musicAuthor": "Apify",
    "musicOriginal": true,
    "playUrl": "https://sf16-ies-music-va.tiktokcdn.com/obj/tos-useast5.mp3",
    "coverMediumUrl": "https://p16.tiktokcdn.com/musicCoverMedium.jpg",
    "originalCoverMediumUrl": "https://p16.tiktokcdn.com/musicCoverLarge.jpg",
    "musicId": "7123456789012345678"
  },
  "webVideoUrl": "https://www.tiktok.com/@apifyoffice/video/7200360993149553925",
  "mediaUrls": [],
  "commentsDatasetUrl": null,
  "videoMeta": {
    "height": 1024,
    "width": 576,
    "duration": 15,
    "coverUrl": "https://p16.tiktokcdn.com/cover.jpg",
    "originalCoverUrl": "https://p16.tiktokcdn.com/originCover.jpg",
    "definition": "540p",
    "format": "mp4",
    "subtitleLinks": []
  },
  "diggCount": 1200,
  "shareCount": 85,
  "playCount": 45210,
  "collectCount": 40,
  "commentCount": 33,
  "repostCount": 0,
  "mentions": [],
  "detailedMentions": [],
  "hashtags": [
    {
      "id": "167890123456789",
      "name": "buildinpublic",
      "title": "",
      "cover": ""
    }
  ],
  "effectStickers": [],
  "isSlideshow": false,
  "isPinned": false,
  "isSponsored": false,
  "submittedVideoUrl": "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
}
```

If a given URL fails to load after retries, the dataset may include an error item:

```json
{
  "error": "404, Not Found",
  "url": "https://www.tiktok.com/@example/video/0000000000000000000"
}
```

Notes:

- Some fields may be empty or null when not present on the public page (e.g., bioLink, subtitleLinks, locationCreated).
- When “Scrape related videos” is enabled, additional items are appended with the same schema. TikTok typically returns 12–16 related items per post.

### FAQ

#### Do I need to log in or provide cookies to use this scraper?

No. This actor targets publicly available TikTok video pages and does not require login or cookies. It functions as a safe tiktok web scraper for public content only.

#### Can it scrape tiktok videos in bulk?

Yes. Provide multiple post URLs in the input and the actor will process them in one run. You can also expand coverage by enabling related video scraping per post.

#### What types of data does it extract?

It returns captions, hashtags, engagement metrics (views, likes, comments, shares, saves, reposts), author details (username, verification, followers), music metadata (title, author, original), video metadata (duration, dimensions, covers), timestamps, and canonical URLs.

#### How many related videos can I collect per post?

You control this with resultsPerPage, but TikTok typically limits related videos to 12–16 per seed post. The actor logs when the platform limit is reached.

#### Is this suitable for developers and APIs?

Yes. Runs can be triggered and results consumed via the Apify API, making it easy to embed a tiktok api scraper step in pipelines or to use with Python/SDK integrations.

#### In which formats can I download results?

Results are stored in an Apify dataset and can be exported to JSON, CSV, or Excel. This makes it easy to use the data in dashboards, notebooks, or BI tools.

#### Is it legal to scrape data from TikTok with this?

Yes, when done responsibly. Only scrape public pages, respect terms of service and privacy laws (e.g., GDPR, CCPA), and consult your legal team for edge cases. The actor does not access private or login-restricted content.

#### Can it work as a tiktok hashtag scraper or trending videos scraper?

The actor collects hashtags for each post and can fetch related videos, supporting workflows often used for hashtag or trend analysis. It is optimized for video-level metadata extraction rather than platform-wide trend discovery.

### Closing thoughts

Tiktok Video Scraper is built to turn public TikTok posts into structured, analysis-ready data. With clean JSON outputs, optional related video expansion, and easy exports, it helps marketers, analysts, and developers quantify performance and accelerate research. Trigger runs via the Apify API to power an automated tiktok video extractor or data pipeline, and start extracting smarter insights at scale today.

# Actor input Schema

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

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

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

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

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

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

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Video Scraper",
        "description": "🎬 TikTok Video Scraper extracts video metadata at scale—captions, hashtags, views, likes, comments, shares, author & audio details, publish date & URLs. 📊 Perfect for trend analysis, competitor research, influencer discovery & content strategy. CSV/JSON-ready.",
        "version": "0.2",
        "x-build-id": "QAmxZ6PfckFq4hvmh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~tiktok-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapapi~tiktok-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapapi~tiktok-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-tiktok-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "postURLs"
                ],
                "properties": {
                    "postURLs": {
                        "title": "Direct URL(s) for scraping specific video(s)",
                        "type": "array",
                        "description": "Add the URLs of posted videos you want to scrape. You can enter URLs one by one, or you can upload or link to a text file.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeRelatedVideos": {
                        "title": "Scrape related videos",
                        "type": "boolean",
                        "description": "Tick to scrape related videos for the post URLs you provide. The maximum number of scraped related videos is set by the resultsPerPage count.",
                        "default": false
                    },
                    "resultsPerPage": {
                        "title": "Number of related videos per post",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Add the number of related videos you want to scrape for each post URL. This field is applicable when the Scrape related videos option is enabled. Note: TikTok typically limits related videos to 12-16 per video.",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
