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

🎥 TikTok Video Scraper extracts video data at scale — captions, hashtags, views, likes, shares, comments, audio & creator info. 🔎 Filter by keyword/hashtag or profile; export CSV/JSON. 📈 Ideal for analytics, trend tracking, competitor research & content strategy.

- **URL**: https://apify.com/scraperx/tiktok-video-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 2 total users, 0 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 fast, Python‑powered TikTok video extractor that turns public TikTok video URLs into clean, structured metadata at scale. It eliminates manual copy‑paste by transforming any list of TikTok links into analysis‑ready records — perfect for marketers, developers, data analysts, and researchers who need a reliable TikTok scraper for engagement analysis, content tracking, and automated insights at scale. 🚀

### What data / output can you get?

Below are real JSON fields the actor saves to the Apify dataset (one record per video). You can export results as JSON, CSV, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| id | TikTok video ID (string) | "7200360993149553925" |
| text | Video description text | "Behind the scenes at Apify HQ 👀" |
| createTimeISO | ISO timestamp of publication | "2025-09-23T16:49:52.000Z" |
| webVideoUrl | Canonical TikTok video URL | "https://www.tiktok.com/@apifyoffice/video/7200360993149553925" |
| authorMeta.name | Author’s username (uniqueId) | "apifyoffice" |
| authorMeta.verified | Author verification flag | true |
| videoMeta.duration | Video duration in seconds | 30 |
| musicMeta.musicName | Music title (or "original sound") | "original sound" |
| playCount | Views | 16900000 |
| diggCount | Likes | 883800 |
| shareCount | Shares | 114800 |
| commentCount | Comments | 58800 |

Bonus fields include locationCreated, authorMeta (profile URL, nickname, avatars, follower stats), musicMeta (IDs, cover art, stream URL), videoMeta (dimensions, covers, subtitles), hashtags (parsed from challenges and text), and flags like isAd, isPinned, isSponsored, and isSlideshow. Exports are available in JSON, CSV, or Excel for flexible integrations.

### Key features

- 🧭 Bold related video discovery — Enable “Scrape related videos” to capture similar videos for each seed post. The count is controlled by resultsPerPage, with practical platform limits of ~12–16 related items per video. Ideal for a TikTok trending videos scraper workflow.
- 🧱 Structured nested JSON output — Consistent objects for authorMeta, musicMeta, and videoMeta simplify downstream analytics, modeling, and any TikTok metadata extractor pipeline.
- ⚡ Async & resilient scraping — Built with Python + aiohttp + Playwright, featuring retry logic and network‑aware navigation for robust public-page scraping.
- 📈 Engagement‑ready metrics — Collect playCount, diggCount, shareCount, commentCount, collectCount, and repostCount to benchmark performance and track trends.
- 🔎 Hashtag and sound insights — Extract hashtags from both challenges and caption text, plus detailed music metadata for sound tracking and research.
- 🧩 Integration‑friendly — Access datasets via the Apify API and export to JSON/CSV/Excel for pipelines, dashboards, and BI tools. Great for building a TikTok video scraper API or TikTok scraper Python workflow.
- 🔒 Public‑only, no login required — Scrapes publicly available video pages without authentication.
- 🧰 Developer‑ready — A production‑oriented TikTok data scraper designed for reliability and repeatability in automation pipelines.

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

1. Sign up or log in to your Apify account.
2. Open the Tiktok Video Scraper actor from your dashboard.
3. Add input data:
   - Paste one or more TikTok video links into postURLs (e.g., https://www.tiktok.com/@apifyoffice/video/7200360993149553925).
   - Optionally enable scrapeRelatedVideos to include similar videos discovered on TikTok.
   - Set resultsPerPage to control how many related videos to fetch per seed post (note: TikTok typically limits related items to ~12–16).
4. Click Start to run the actor (or trigger via the Apify API for automation).
5. Monitor progress in the console; the actor fetches each public video page and normalizes the metadata.
6. When finished, open the Dataset tab to review results.
7. Export your data in JSON, CSV, or Excel for analysis or ingestion into your systems.
8. Pro tip: Use this as the metadata core for a TikTok bulk video downloader workflow — this actor focuses on metadata extraction; downloading media or attempting to download TikTok videos without watermark is intentionally out of scope.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing trend analysis | Track engagement (views, likes, comments, shares) to benchmark campaign performance and discover what resonates. |
| Influencer performance tracking | Monitor creator metrics via authorMeta and engagement fields to evaluate partnerships and spot rising accounts. |
| Hashtag and sound research | Analyze hashtags and musicMeta to understand which sounds and tags drive reach in your niche. |
| Competitive monitoring | Collect structured data from competitor posts to inform content strategy and positioning. |
| Data enrichment for analytics | Feed normalized JSON into your BI stack for dashboards, cohort analysis, and data modeling. |
| Academic & behavioral research | Study posting cadence, engagement, and content features using timestamps, durations, and metadata. |
| Automation pipelines (API) | Orchestrate scheduled scrapes and exports using the Apify API for reproducible, code‑driven workflows. |

### Why choose Tiktok Video Scraper?

Built for precision and scale, this TikTok video scraper emphasizes clean metadata, reliability, and repeatable workflows.

- ✅ Accurate, structured output: Nested authorMeta, musicMeta, and videoMeta objects ready for analysis.
- 🌍 Public, no‑login access: Works on publicly available video pages without authentication complexities.
- 📊 Engagement‑first fields: Captures views, likes, comments, shares, saves, and reposts for performance measurement.
- 🧰 Developer‑friendly: Python stack with Playwright and aiohttp suited to automation and API pipelines (great for a TikTok video scraper Python setup).
- 🚀 Scalable runs: Process many postURLs in a single run; optionally append related videos for discovery.
- 🔁 Resilient by design: Retry logic and network‑idle waits improve extraction success versus brittle browser extensions.
- 🧩 Easy exports & API access: Pull records via the Apify API and export to JSON/CSV/Excel for seamless integration.

Compared to browser extensions or ad‑hoc scripts, this production‑ready TikTok scraper provides consistent structure, better resilience, and platform‑level exports that keep your pipelines stable.

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

Yes — when used responsibly. This actor collects data from publicly available TikTok video pages and does not access private or authenticated content.

- Only scrape public pages and publicly visible metadata.
- Do not attempt to access private accounts or login‑restricted content.
- Ensure your use complies with applicable regulations (e.g., GDPR, CCPA) and TikTok’s terms.
- Avoid storing sensitive personal data; consult your legal team for edge cases.

### Input parameters & output format

Below is a real JSON example you can use to start a run:

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

Input fields

- postURLs (array) — Direct URL(s) for scraping specific video(s). Enter URLs one by one or upload/link a text file. Default: —. Required: Yes.
- scrapeRelatedVideos (boolean) — Scrape related videos for each provided post URL. The number scraped is set by resultsPerPage. Default: false. Required: No.
- resultsPerPage (integer) — Number of related videos per post when scrapeRelatedVideos is enabled. Note: TikTok typically limits related items to 12–16 per video. Default: 10. Required: No.

Output format

Each successful item is a normalized JSON object pushed to the dataset. Some entries may be error objects if a URL fails due to a network or page‑load error.

Example success record:

```json
{
  "id": "7200360993149553925",
  "text": "Behind the scenes at Apify HQ 👀",
  "textLanguage": "en",
  "createTime": 1695487792,
  "createTimeISO": "2025-09-23T16:49:52.000Z",
  "locationCreated": "US",
  "isAd": false,
  "authorMeta": {
    "id": "6951234567890123457",
    "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.jpeg",
    "avatar": "https://p16-sign-va.tiktokcdn.com/…/avatarMedium.jpeg",
    "privateAccount": false,
    "roomId": "",
    "ttSeller": false,
    "followDatasetUrl": null,
    "following": 120,
    "friends": 50,
    "fans": 128450,
    "heart": 3450000,
    "video": 320,
    "digg": 0
  },
  "musicMeta": {
    "musicName": "original sound",
    "musicAuthor": "Apify",
    "musicOriginal": true,
    "playUrl": "https://sf16-ies-music.tiktokcdn.com/…/music.mp3",
    "coverMediumUrl": "https://p16-tiktokcdn-com.akamaized.net/…/cover.jpg",
    "originalCoverMediumUrl": "https://p16-tiktokcdn-com.akamaized.net/…/cover.jpg",
    "musicId": "7159876543210987654"
  },
  "webVideoUrl": "https://www.tiktok.com/@apifyoffice/video/7200360993149553925",
  "mediaUrls": [],
  "commentsDatasetUrl": null,
  "videoMeta": {
    "height": 1024,
    "width": 576,
    "duration": 30,
    "coverUrl": "https://p16-sign-va.tiktokcdn.com/…/cover.jpeg",
    "originalCoverUrl": "https://p16-sign-va.tiktokcdn.com/…/originCover.jpeg",
    "definition": "720p",
    "format": "mp4",
    "subtitleLinks": []
  },
  "diggCount": 883800,
  "shareCount": 114800,
  "playCount": 16900000,
  "collectCount": 4200,
  "commentCount": 58800,
  "repostCount": 120,
  "mentions": [],
  "detailedMentions": [],
  "hashtags": [
    {
      "id": "1234567890",
      "name": "automation",
      "title": "Automation",
      "cover": "https://p16.tiktokcdn.com/…/hashtag.jpg"
    },
    {
      "name": "apify"
    }
  ],
  "effectStickers": [],
  "isSlideshow": false,
  "isPinned": false,
  "isSponsored": false,
  "submittedVideoUrl": "https://www.tiktok.com/@apifyoffice/video/7200360993149553925"
}
```

Example error record (if a URL fails):

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

Note: resultsPerPage can be set up to 1,000,000, but TikTok typically returns only ~12–16 related items per video.

### FAQ

#### Is there a free trial or pricing?

Yes. The listing currently offers a flat monthly price of $19.99 with 120 trial minutes included. You can start a run to evaluate fit before upgrading.

#### Do I need to log in or provide cookies?

No. The actor targets publicly available TikTok video pages and does not require login or cookies.

#### Can this download TikTok videos or remove watermarks?

No. This is a TikTok video metadata scraper, not a TikTok video downloader. It focuses on structured fields for analysis. You can combine the metadata with your own tooling if you need a TikTok bulk video downloader, but downloading (including attempts to download TikTok videos without watermark) is out of scope.

#### Can I scrape related videos to a specific post?

Yes. Enable scrapeRelatedVideos and set resultsPerPage to collect related items per seed post. Platform limits mean you’ll typically see ~12–16 related videos per seed.

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

It returns rich metadata including id, text, createTime and createTimeISO, authorMeta (username, avatar, verification, follower stats), musicMeta (title, author, IDs, covers), videoMeta (duration, dimensions, covers, subtitles), and engagement metrics such as playCount, diggCount, shareCount, commentCount, collectCount, and repostCount, plus hashtags and flags (isAd, isPinned, isSponsored, isSlideshow).

#### Does it scrape comments?

No. Comments are not collected by this actor. The output includes commentsDatasetUrl set to null to make this explicit.

#### How many videos can I scrape in one run?

You can pass many postURLs in a single run. For related videos, resultsPerPage controls the target count per seed, but TikTok typically provides only ~12–16 related items. Overall scale depends on your input size and runtime constraints.

#### Is it suitable for developers and API workflows?

Yes. Runs on Apify with dataset exports and API access, and the codebase is Python with Playwright and aiohttp. It’s a solid foundation for a TikTok video scraper API or a TikTok video scraper Python pipeline.

### Closing CTA / Final thoughts

Tiktok Video Scraper is built to turn public TikTok video URLs into structured, analysis‑ready records with speed and reliability. With rich engagement metrics, nested author/music/video metadata, and optional related video discovery, it serves marketers, developers, analysts, and researchers alike. Use the Apify API to automate your TikTok data flows, export to CSV/JSON/Excel for dashboards, or integrate it as the backbone of a broader TikTok data pipeline. Start extracting smarter TikTok insights 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("scraperx/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("scraperx/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 scraperx/tiktok-video-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperx/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 data at scale — captions, hashtags, views, likes, shares, comments, audio & creator info. 🔎 Filter by keyword/hashtag or profile; export CSV/JSON. 📈 Ideal for analytics, trend tracking, competitor research & content strategy.",
        "version": "0.2",
        "x-build-id": "VVF38086cuhPsnwNA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~tiktok-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-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/scraperx~tiktok-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-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/scraperx~tiktok-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
