# TikTok Search Scraper (`chronometrica/tiktok-search-scraper`) Actor

Search public TikTok keywords and export clean, structured video discovery rows with URLs, post IDs, views, likes, comments, shares, saves, author stats, and query context. Built for reliable trend tracking, UGC research, creator discovery, and competitor monitoring. No login required.

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

## Pricing

from $2.00 / 1,000 tiktok discovery 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 Search Scraper

### 🔎 What does TikTok Search Scraper do?

TikTok Search Scraper searches public TikTok keywords, then exports clean,
structured video discovery rows with TikTok video URLs, post IDs, captions,
publish timestamps, views, likes, comments, shares, saves, author identity,
author stats, and query provenance.

Use it for reliable trend tracking, UGC research, creator discovery, competitor
monitoring, content research, social listening, and data-pipeline seeding when
you need a list of TikTok video candidates for a topic before doing deeper
analysis.

With TikTok Search Scraper, you can:

- 🔍 Search TikTok by one keyword or many keywords.
- 📎 Export TikTok video URLs and stable `postId` values.
- 📊 Collect public views, likes, comments, shares, and saves when TikTok
  exposes them in search results.
- 👤 Get author handles, author IDs, profile URLs, verification, follower
  counts, total likes, and video counts when available publicly.
- 🧭 Preserve search context with `rootQuery`, `query`, `querySource`,
  `pageIndex`, and `pageRank`.
- 🧪 Run broad concept panels with balanced distribution across query families.
- 🔁 Optionally add TikTok-native related searches for wider discovery.
- 📦 Download results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

This Actor uses logged-out public TikTok web search surfaces. No login is
required. It does not use search engines, TikTok API keys, user cookies,
logged-in accounts, private analytics, comment text scraping, or video
downloads.

### ✨ What You Get

Each dataset row represents one discovered public TikTok video candidate.

| Data group         | Example fields                                                                                |
| ------------------ | --------------------------------------------------------------------------------------------- |
| 🔍 Query context   | `rootQuery`, `query`, `querySource`, `pageIndex`, `pageRank`                                  |
| 🔗 Video identity  | `postUrl`, `postId`                                                                           |
| 🧾 Video metadata  | `description`, `publishedAt`                                                                  |
| 👤 Author identity | `authorId`, `authorSecUid`, `profileHandle`, `profileUrl`, `authorNickname`, `authorVerified` |
| 👥 Author stats    | `authorFollowerCount`, `authorFollowingCount`, `authorHeartCount`, `authorVideoCount`         |
| 📊 Post metrics    | `views`, `likes`, `comments`, `shares`, `saves`                                               |
| 🚦 Row status      | `status`, `statusReason`, `observedAt`                                                        |

Metric availability depends on what TikTok exposes publicly for each search
result at run time. Missing counts stay missing; they are not guessed and they
are not replaced with fake zeroes.

### ⚙️ Can I use this Actor through an API?

Yes. You can run TikTok Search Scraper manually in Apify Console or use it
through:

- Apify API
- Python SDK
- Node.js SDK
- Webhooks
- Scheduled runs
- Apify integrations

This makes it useful for research pipelines, creator databases, trend monitors,
content intelligence dashboards, enrichment queues, and automated market
research workflows.

### 🎯 Why scrape TikTok search results?

TikTok search results show what videos TikTok currently surfaces for a topic.
This is useful when you need to understand which concepts, creators, hooks,
keywords, and content angles are visible in a market.

| Use case                 | How TikTok search data helps                                                     |
| ------------------------ | -------------------------------------------------------------------------------- |
| 🔥 Concept research      | Find videos ranking for a topic before deciding what to analyze next.            |
| 📈 Trend discovery       | Compare topics by visible videos, views, likes, comments, and author context.    |
| 🧑‍🎨 Creator discovery     | Build lists of creators publishing around a niche, product, keyword, or format.  |
| 🕵️ Competitor monitoring | See what content appears for competitor, category, or product keywords.          |
| 🧱 Data pipeline seeding | Feed discovered TikTok URLs into downstream metrics, databases, or review flows. |
| 🧭 Content planning      | Study captions, ranks, query language, creator mix, and visible engagement.      |

### 💵 Pricing Event

TikTok Search Scraper uses pay-per-result pricing. One result means one unique
TikTok video discovery row written to the default dataset.

Use `maxResults` to control result volume before a run. Start with 10 to 25
results when testing a keyword, then increase the cap for broader concept
research.

### 🚀 How do I use TikTok Search Scraper?

1. Create or log in to your Apify account.
2. Open **TikTok Search Scraper**.
3. Enter one or more TikTok keyword searches.
4. Set the maximum number of unique videos to collect.
5. Leave related search expansion off for the cleanest direct keyword panel, or
   enable it for broader concept discovery.
6. Click **Start**.
7. Open the **Output** tab to inspect the dataset and run summary.
8. Download your data in JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### ⬇️ Input

The main input is `queries`. Enter one or more TikTok keyword searches.

```json
{
    "queries": ["ugc ad examples"],
    "maxResults": 25,
    "resultsPerQuery": 25,
    "maxPagesPerQuery": 1
}
````

For broader concept discovery, enter multiple related queries and enable
TikTok-native related searches:

```json
{
    "queries": [
        "ugc ad examples",
        "small business marketing ideas",
        "ai tools for small business",
        "productivity hacks"
    ],
    "searchDistribution": "balanced",
    "maxResults": 50,
    "resultsPerQuery": 15,
    "maxPagesPerQuery": 2,
    "expandQueries": true,
    "maxExpandedQueries": 5
}
```

#### 🎛️ Settings

| Option               | What it does                                                                                        |
| -------------------- | --------------------------------------------------------------------------------------------------- |
| `queries`            | TikTok topics, keywords, or phrases to search. Each entry becomes a TikTok search term.             |
| `maxResults`         | Maximum unique TikTok video rows to save across the whole run.                                      |
| `resultsPerQuery`    | Maximum unique videos to collect from each searched term before the total cap is reached.           |
| `maxPagesPerQuery`   | Maximum TikTok search result pages or cursors to try for each search term. Higher values cost more. |
| `searchDistribution` | `balanced` rotates across terms; `sequential` fills earlier terms before later terms.               |
| `expandQueries`      | Adds TikTok-suggested related search phrases for broader concept discovery.                         |
| `maxExpandedQueries` | Maximum TikTok-suggested related phrases to add. This adds search terms, not extra video quota.     |

Balanced mode is best for broad concept panels because it gives each query a
turn before going deeper. Sequential mode is best when earlier queries should
take priority.

### ⬆️ Output sample

Results are stored in the default dataset. Each result is one discovered
TikTok video candidate.

```json
{
    "platform": "tiktok",
    "rootQuery": "ugc ad examples",
    "query": "ugc ad examples",
    "querySource": "input",
    "pageIndex": 0,
    "pageRank": 6,
    "postUrl": "https://www.tiktok.com/@juliets.ugc/video/7569000459701161247",
    "postId": "7569000459701161247",
    "authorId": "6759284387357443078",
    "authorSecUid": "MS4wLjABAAAAkGUBbxjBZIhCe2L8vg-3oyxbQDuvVPKL1MhHQbxdg7sssxWapSK8KPuAor1US8nU",
    "authorNickname": "Juliet | UGC & Travel Creator",
    "authorVerified": false,
    "authorFollowerCount": 39400,
    "authorHeartCount": 280200,
    "authorVideoCount": 183,
    "profileHandle": "juliets.ugc",
    "profileUrl": "https://www.tiktok.com/@juliets.ugc",
    "description": "No materials needed! All you need is a plain wall, some natural lighting, and your good to go. Using my absolute favorite @Kiehl's Since 1851 product, the Retinol Skin-Renewing Daily Micro-Dose Serum.",
    "publishedAt": "2025-11-04T22:27:51.000Z",
    "views": 1200000,
    "likes": 60800,
    "comments": 1371,
    "shares": 11900,
    "saves": 60900,
    "status": "ok",
    "statusReason": null,
    "observedAt": "2026-07-02T00:09:38.094Z"
}
```

### 🧭 Query fields explained

`rootQuery` is the original search term you entered.

`query` is the exact term searched on TikTok. When related searches are off,
`query` usually matches `rootQuery`. When related searches are on, `query` may
be a TikTok-suggested related search.

`querySource` explains where the searched query came from:

- `input` means the query was entered directly by the user.
- `related_search` means TikTok suggested the related search term.

`pageIndex` is the TikTok search page or cursor number, starting at `0` for the
first page.

`pageRank` is the video's position within that page when TikTok exposes a
page-shaped search payload. It is not a virality or relevance score.

### 🧾 Run Summary

The `OUTPUT` key-value-store record includes:

- `urls`: discovered TikTok video URLs;
- `videoCandidates`: compact candidate rows with immediate metadata;
- field coverage and metric coverage;
- candidate, duplicate, cap, and stop-reason counters;
- per-query accounting.

If no videos are found, the Actor does not fail the run. It returns a
successful run summary with `status: "no_public_results"` and a `statusReason`
explaining the outcome.

### 🔒 Source Boundary

TikTok Search Scraper uses logged-out public TikTok web search surfaces only.

It does not use:

- TikTok API keys;
- user cookies;
- private sessions;
- logged-in account automation;
- search engines;
- private TikTok analytics;
- challenge solving;
- comment text scraping;
- video downloads.

### ⚠️ Limits and interpretation

TikTok search ranking and result availability are live public TikTok behavior
and can change between runs.

`maxResults` is a saved-row cap, not a guarantee that TikTok has that many
public candidates for every query. Narrow queries may source-exhaust below the
requested cap.

TikTok native search can return broad matches. Use the query provenance fields
to decide which rows to keep downstream.

This Actor does not compute a proprietary virality score. When TikTok exposes
metrics in public search payloads, users can rank rows directly by views,
likes, comments, shares, saves, author follower count, and query context.

### ❓ FAQ

#### Does this Actor need a TikTok API key?

No. It uses logged-out public TikTok web surfaces and does not require a TikTok
API key.

#### Does this Actor scrape private TikTok data?

No. It only returns data available from logged-out public TikTok surfaces.

#### Does this Actor use Google or other search engines?

No. Discovery comes from TikTok public search surfaces, not external search
engines.

#### Does this Actor download videos or scrape comments?

No. It discovers video candidates and returns public metadata and metrics when
available.

# Actor input Schema

## `queries` (type: `array`):

Topics, keywords, or phrases to search directly on TikTok. Each entry becomes a TikTok search term.

## `expandQueries` (type: `boolean`):

Also search TikTok-suggested related phrases for your input terms. Useful for broader concept and trend discovery.

## `maxExpandedQueries` (type: `integer`):

Maximum number of TikTok-suggested related search phrases to add across the whole run. This adds more searched terms; it does not increase the max videos to save.

## `maxResults` (type: `integer`):

Total maximum number of unique TikTok video rows to save across all search terms.

## `resultsPerQuery` (type: `integer`):

Maximum unique videos to collect from each searched term before the total max videos cap is reached. Balanced distribution may lower the effective per-term limit.

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

Maximum TikTok search result pages or cursors to try for each search term. Higher values can find more videos but may cost more and take longer.

## `searchDistribution` (type: `string`):

Balanced shares the max videos cap across search terms. Sequential fills earlier search terms first, then moves to later terms.

## Actor input object example

```json
{
  "queries": [
    "ugc ad examples"
  ],
  "expandQueries": false,
  "maxExpandedQueries": 5,
  "maxResults": 25,
  "resultsPerQuery": 25,
  "maxPagesPerQuery": 1,
  "searchDistribution": "balanced"
}
```

# Actor output Schema

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

No description

## `output` (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 = {
    "queries": [
        "ugc ad examples"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "queries": ["ugc ad examples"] }

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "ugc ad examples"
  ]
}' |
apify call chronometrica/tiktok-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Search Scraper",
        "description": "Search public TikTok keywords and export clean, structured video discovery rows with URLs, post IDs, views, likes, comments, shares, saves, author stats, and query context. Built for reliable trend tracking, UGC research, creator discovery, and competitor monitoring. No login required.",
        "version": "1.0",
        "x-build-id": "m4ks6d2VgUGBvByDV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~tiktok-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-tiktok-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/chronometrica~tiktok-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-tiktok-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/chronometrica~tiktok-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-tiktok-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "TikTok search terms",
                        "minItems": 1,
                        "type": "array",
                        "description": "Topics, keywords, or phrases to search directly on TikTok. Each entry becomes a TikTok search term.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "ugc ad examples"
                        ]
                    },
                    "expandQueries": {
                        "title": "Add related TikTok searches",
                        "type": "boolean",
                        "description": "Also search TikTok-suggested related phrases for your input terms. Useful for broader concept and trend discovery.",
                        "default": false
                    },
                    "maxExpandedQueries": {
                        "title": "Max related searches",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of TikTok-suggested related search phrases to add across the whole run. This adds more searched terms; it does not increase the max videos to save.",
                        "default": 5
                    },
                    "maxResults": {
                        "title": "Max videos to save",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Total maximum number of unique TikTok video rows to save across all search terms.",
                        "default": 25
                    },
                    "resultsPerQuery": {
                        "title": "Videos per search term",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum unique videos to collect from each searched term before the total max videos cap is reached. Balanced distribution may lower the effective per-term limit.",
                        "default": 25
                    },
                    "maxPagesPerQuery": {
                        "title": "Search pages per term",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum TikTok search result pages or cursors to try for each search term. Higher values can find more videos but may cost more and take longer.",
                        "default": 1
                    },
                    "searchDistribution": {
                        "title": "Result distribution",
                        "enum": [
                            "balanced",
                            "sequential"
                        ],
                        "type": "string",
                        "description": "Balanced shares the max videos cap across search terms. Sequential fills earlier search terms first, then moves to later terms.",
                        "default": "balanced"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
