# TikTok Transcript Scraper – Text & Timestamps (`chronometrica/tiktok-transcript-scraper`) Actor

Get clean TikTok transcript text and timestamped segments from public videos. Add video URLs or IDs, choose a language, and pay only when a transcript is returned.

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

## Pricing

from $1.50 / 1,000 successful native transcripts

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 Transcript Scraper – Text & Timestamps

### 🎬 What does TikTok Transcript Scraper do?

Paste public TikTok video URLs or numeric video IDs. Get clean transcript text
and timestamped segments that are ready to use.

Use it for AI workflows, research, subtitling, content analysis, spreadsheets,
and batch automation. Each input creates one clear result row. A successful
transcript is charged once. Every other outcome stays visible and free.

The Actor uses public, logged-out TikTok video pages. It does not require an
API key, account, cookies, or login from you.

With TikTok Transcript Scraper, you can:

- 🤖 Send clean, consistent transcript text straight into LLMs, RAG pipelines,
  agents, embeddings, and summaries.
- ⏱️ Get timestamps for each transcript segment for clips, quotes, NLP, and
  re-subtitling.
- 📦 Process up to 100 direct TikTok videos in one batch.
- 🌐 Choose transcript languages in priority order without automatic translation.
- 🚦 See a clear row for every input, including no-caption, duplicate, invalid,
  unavailable, and blocked outcomes.
- 💸 Pay only when a non-empty transcript is returned.

### ✨ Why use this Actor?

Buyers use TikTok transcripts when they need text that is easy to reuse, not a
wall of unstructured output. The Actor returns a joined `text` field for quick
use and timestamped `segments` for precise work.

- **Clean and consistent:** one stable row shape for every submitted input.
- **Ready for automation:** use the Apify API, webhooks, schedules, Make, n8n,
  Zapier, or your own code.
- **Clear language choice:** provide preferred caption languages, or leave the
  list empty to use the first public caption track TikTok exposes.
- **No surprise result charges:** status rows are useful audit records, but
  only a successful native transcript is billable.
- **Honest limits:** the Actor reads public caption tracks. It does not invent
  text when TikTok has no public captions.

### 📦 What data do I get?

Each dataset row represents one submitted TikTok video input.

| Data group            | Fields                                                                             |
| --------------------- | ---------------------------------------------------------------------------------- |
| 🔗 Input and video    | `inputIndex`, `inputUrl`, `videoId`, `videoUrl`, `authorHandle`, `durationSeconds` |
| 📝 Transcript         | `languageCode`, `segments` (`startSeconds`, `endSeconds`, `text`), `text`          |
| 🚦 Result and billing | `status`, `statusReason`, `isBillable`, `scrapedAt`                                |

Successful rows contain non-empty `text` plus timestamped segments. If public
captions are unavailable, the transcript fields are empty or `null`, the row
explains why, and `isBillable` is `false`.

Fields are ordered from your input, to the resolved video, selected caption,
transcript, result, and scrape time. This makes CSV and spreadsheet reviews
follow the same path as the Actor.

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

Yes. Run TikTok Transcript Scraper in Apify Console or through:

- Apify API
- Python SDK
- Node.js SDK
- Webhooks
- Scheduled runs
- Make, n8n, Zapier, and other Apify integrations

That makes it a good fit for repeatable research, content pipelines, and batch
workflows.

### 💵 Pricing: successful native transcripts only

The Actor uses one Pay per Event event: **Successful native transcript**.

You are charged only when TikTok provides a non-empty public caption transcript.
Rows for no public captions, duplicate inputs, invalid URLs, unavailable videos,
or temporary public-source failures are returned without that event charge.

| Apify Store tier | Price per successful transcript | Price per 1,000 successful transcripts |
| ---------------- | ------------------------------: | -------------------------------------: |
| No discount      |                        $0.00300 |                                  $3.00 |
| Bronze           |                        $0.00250 |                                  $2.50 |
| Silver           |                        $0.00200 |                                  $2.00 |
| Gold             |                        $0.00150 |                                  $1.50 |
| Platinum         |                        $0.00150 |                                  $1.50 |
| Diamond          |                        $0.00150 |                                  $1.50 |

Your run can use Apify's maximum-charge limit. Start with a small batch to
check caption coverage for your video list.

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

1. Open **TikTok Transcript Scraper** in Apify Console.
2. Paste one or more public TikTok video links or video IDs.
3. Optionally choose a caption language from the dropdown.
4. Click **Start**.
5. Open **Output** to inspect the transcript rows and the run summary.
6. Download JSON, JSONL, CSV, Excel, XML, RSS, or HTML, or send results to an
   integration.

Here is the exact first-run example used for the release smoke:

```json
{
    "startUrls": ["https://www.tiktok.com/@hankgreen1/video/7047596209028074758"],
    "preferredLanguages": ["en"]
}
````

### ⬇️ Input

| Option               | What it controls                                                                                                                                                                                            |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `startUrls`          | Add 1–100 public TikTok video links, short links, or video IDs. Profile, search, and sound links return a free not-supported row.                                                                           |
| `preferredLanguages` | Optional. Choose common languages from the dropdown in the order you prefer. Leave this blank to use the first public caption. If unavailable, the video gets a free status. This setting never translates. |

For a batch, add more direct video URLs:

```json
{
    "startUrls": [
        "https://www.tiktok.com/@hankgreen1/video/7047596209028074758",
        "https://www.tiktok.com/@example/video/1234567890123456789"
    ],
    "preferredLanguages": ["en", "es"]
}
```

Use real public TikTok video links in your own runs. The second URL above only
shows the accepted URL shape.

### ⬆️ Output sample

```json
{
    "inputIndex": 0,
    "inputUrl": "https://www.tiktok.com/@hankgreen1/video/7047596209028074758",
    "videoId": "7047596209028074758",
    "videoUrl": "https://www.tiktok.com/@hankgreen1/video/7047596209028074758",
    "authorHandle": "hankgreen1",
    "durationSeconds": 21,
    "languageCode": "eng-US",
    "text": "Example public-caption transcript text.",
    "segments": [
        {
            "startSeconds": 0.044,
            "endSeconds": 0.704,
            "text": "Example public-caption segment"
        }
    ],
    "status": "succeeded",
    "statusReason": "TikTok provided a public caption track that was parsed successfully.",
    "isBillable": true,
    "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

#### 📌 Run summary

The `OUTPUT` record summarizes the run with buyer-facing counts:

- inputs received and result rows written;
- billable transcripts and free result rows;
- duplicate inputs skipped;
- status counts, including no-public-caption outcomes.

Use the summary to check your whole batch before loading the transcript rows
into a database or automation.

### 🚦 Result statuses and billing

| Status                                                                                    | What it means                                                                      | Charged? |
| ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | -------- |
| `succeeded`                                                                               | TikTok exposed a public caption track and the Actor parsed a non-empty transcript. | Yes      |
| `no_public_captions`                                                                      | The public video resolved, but TikTok exposed no usable caption track.             | No       |
| `language_unavailable`                                                                    | TikTok exposed public captions, but none matched the requested language.           | No       |
| `duplicate_input`                                                                         | The same video was already included earlier in this run.                           | No       |
| `not_tiktok`, `invalid_input`, or `unsupported_url`                                       | The input was not a supported TikTok video object.                                 | No       |
| `video_unavailable`, `not_public`, `blocked_or_challenged`, or extraction/caption failure | The Actor could not return a defensible public transcript for this input.          | No       |

This makes a mixed batch easy to use: successful rows contain transcripts;
other rows explain what happened without pretending an empty string is a
transcript.

### 🔒 Public-source boundary

TikTok Transcript Scraper reads existing public caption tracks from logged-out
public TikTok video pages.

It does not:

- generate AI speech-to-text when TikTok has no public captions;
- download video or audio for customer transcription;
- use TikTok accounts, cookies, private sessions, or API keys;
- access private, login-only, deleted, or unavailable videos;
- solve challenges or bypass access controls;
- search TikTok, expand profiles, scrape comments, or collect private analytics.

For keyword, creator, or profile workflows, first use a discovery Actor and
then send its direct TikTok video URLs to this Actor.

### ⚠️ Limits and interpretation

Caption availability is live TikTok behavior. A public video can exist without
a public caption track, and a caption track can change or disappear between
runs. This Actor returns TikTok's public captions as exposed at run time; it
does not promise that every public video has captions.

Use `preferredLanguages` when language matters. If no matching public caption
track is available, the row remains free and explains the result instead of
silently translating to another language.

### ❓ FAQ

#### Does this Actor need a TikTok account, cookie, or API key?

No. It uses logged-out public TikTok video pages and public caption tracks.

#### Why did I get a row without a transcript?

The row is a clear result for your submitted input. TikTok may not expose a
public caption track, the input may be unsupported, or the public page may be
temporarily unavailable. Check `status` and `statusReason`. These rows are not
billed as successful native transcripts.

#### Does it translate captions?

No. It selects from public caption tracks TikTok exposes. Set
`preferredLanguages` to choose the language you want when it is available.

#### Can I run many links in one task?

Yes. Add up to 100 direct video inputs to `startUrls`. Each input gets one
result row, so batch automation can keep its input-to-output accounting.

#### Why can a small run take a little time to start?

Apify starts a container for the run. Once it starts, the Actor processes up to
three videos at a time. Use batches when you have more than one video.

### 🛟 Support

For help, include the run ID, one affected input, the expected result, the row
you received, and whether the issue is missing text, wrong language, duplicate
handling, status, cost, or runtime. This gives us enough information to check
the public result without asking for your TikTok account or private data.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

# Actor input Schema

## `startUrls` (type: `array`):

Add 1–100 public video links, short links, or video IDs. Profile, search, and sound links return a free not-supported row.

## `preferredLanguages` (type: `array`):

Choose one or more languages in the order you prefer. Leave this blank to use the first public caption. If TikTok does not have your choice, that video gets a free status. We do not translate.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.tiktok.com/@hankgreen1/video/7047596209028074758"
  ],
  "preferredLanguages": []
}
```

# 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 = {
    "startUrls": [
        "https://www.tiktok.com/@hankgreen1/video/7047596209028074758"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/tiktok-transcript-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 = { "startUrls": ["https://www.tiktok.com/@hankgreen1/video/7047596209028074758"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/tiktok-transcript-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 '{
  "startUrls": [
    "https://www.tiktok.com/@hankgreen1/video/7047596209028074758"
  ]
}' |
apify call chronometrica/tiktok-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Transcript Scraper – Text & Timestamps",
        "description": "Get clean TikTok transcript text and timestamped segments from public videos. Add video URLs or IDs, choose a language, and pay only when a transcript is returned.",
        "version": "0.1",
        "x-build-id": "mVgqNXZwKlCmvGaxE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~tiktok-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-tiktok-transcript-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-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-tiktok-transcript-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-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-tiktok-transcript-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "TikTok video links",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add 1–100 public video links, short links, or video IDs. Profile, search, and sound links return a free not-supported row.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\s*\\S[\\s\\S]*$"
                        }
                    },
                    "preferredLanguages": {
                        "title": "Caption language",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more languages in the order you prefer. Leave this blank to use the first public caption. If TikTok does not have your choice, that video gets a free status. We do not translate.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en",
                                "es",
                                "pt",
                                "fr",
                                "de",
                                "it",
                                "nl",
                                "pl",
                                "tr",
                                "ru",
                                "uk",
                                "ar",
                                "hi",
                                "bn",
                                "id",
                                "vi",
                                "th",
                                "ja",
                                "ko",
                                "zh"
                            ],
                            "enumTitles": [
                                "English",
                                "Spanish",
                                "Portuguese",
                                "French",
                                "German",
                                "Italian",
                                "Dutch",
                                "Polish",
                                "Turkish",
                                "Russian",
                                "Ukrainian",
                                "Arabic",
                                "Hindi",
                                "Bengali",
                                "Indonesian",
                                "Vietnamese",
                                "Thai",
                                "Japanese",
                                "Korean",
                                "Chinese"
                            ]
                        },
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
