# TikTok AI Transcript Extractor (`fetch_cat/best-tiktok-ai-transcript-extractor`) Actor

Extract public TikTok captions, transcript text, timestamped segments, video metadata, creator details, hashtags, music, and clear skip reasons from video URLs.

- **URL**: https://apify.com/fetch\_cat/best-tiktok-ai-transcript-extractor.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.23 / 1,000 result extracteds

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 AI Transcript Extractor

Turn public TikTok videos into structured transcript data for research, repurposing, social listening, and content analysis.

The TikTok AI Transcript Extractor helps creators, agencies, analysts, and developers process batches of public TikTok video URLs and receive clean dataset rows with video metadata, transcript status, caption text when available, timestamped segments, hashtags, creator details, music information, engagement counts, and explicit skip reasons.

### What does TikTok AI Transcript Extractor do?

This actor processes public TikTok video URLs and returns structured data that is ready for spreadsheets, dashboards, databases, and automation workflows.

It is useful when you need to:

- 🎬 Build a searchable archive of TikTok content
- 📝 Extract public captions and subtitle segments
- 📊 Combine video metadata with transcript availability
- 🔎 Audit which videos have public caption tracks
- 🚦 Keep skipped, private, deleted, or unavailable videos visible in your batch report
- 📦 Export clean JSON, CSV, Excel, XML, or RSS from Apify datasets

### Who is it for?

#### Content creators

Use transcripts and captions to repurpose short-form videos into blog posts, newsletters, captions, scripts, and social posts.

#### Agencies

Process client or competitor TikTok URLs in batches and prepare structured reports for creative strategy, social listening, and campaign analysis.

#### Researchers

Collect public video metadata and available transcript text for qualitative analysis, topic tracking, and searchable content archives.

#### Social listening teams

Monitor public videos, hashtags, scripts, music usage, and caption availability across a curated URL list.

#### Developers

Connect TikTok transcript extraction to your own pipelines with Apify API, webhooks, scheduled runs, and MCP tools.

### Why use this actor?

- ✅ Batch input for many public TikTok video URLs
- ✅ Clean one-row-per-video output
- ✅ Transcript text when public captions are available
- ✅ Timestamped transcript segments when subtitle timing is available
- ✅ Explicit `status` and `errorReason` fields for every URL
- ✅ Video metadata such as author, description, duration, hashtags, music, and engagement counts
- ✅ Proxy configuration support for reliability
- ✅ Works with Apify datasets, integrations, API clients, and MCP

### What data can you extract?

| Field | Description |
| --- | --- |
| `url` | Original input URL |
| `canonicalUrl` | Normalized TikTok video URL when available |
| `videoId` | TikTok video ID |
| `authorUsername` | Public creator username |
| `authorName` | Public creator display name |
| `description` | TikTok video caption / description |
| `duration` | Video duration in seconds |
| `createTimeISO` | Publish time in ISO format when available |
| `musicTitle` | Music or original sound title |
| `hashtags` | Hashtags attached to the video |
| `stats` | Public play, like, comment, share, and collect counts when available |
| `transcriptText` | Combined transcript text when public captions are available |
| `segments` | Timestamped transcript segments |
| `language` | Caption language when available |
| `transcriptionSource` | Source of transcript data |
| `status` | `success`, `skipped`, or `failed` |
| `errorReason` | Human-readable reason for skipped or failed URLs |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to extract TikTok transcripts?

This actor uses pay-per-event pricing. A small start event covers run initialization and a per-result event is charged for each processed TikTok URL that is written to the dataset.

Typical test runs with a few URLs are inexpensive. For larger batches, use `maxItems` to control the run size and review your estimated maximum charge in Apify before starting the run.

### Input options

#### `videoUrls`

Paste public TikTok video URLs. Direct `/video/` links work best.

#### `startUrls`

Optional advanced URL input compatible with Apify request-list objects. These URLs are merged with `videoUrls`.

#### `maxItems`

Caps the number of URLs processed from the combined input list.

#### `preferredLanguage`

Preferred caption language code such as `en`, `es`, `de`, or `fr`.

#### `includeMetadata`

Turn metadata extraction on or off. Most users should leave this enabled.

#### `maxConcurrency`

Controls how many URLs are processed at once. Lower values are more reliable for TikTok.

#### `proxyConfiguration`

Optional Apify Proxy settings. Start with the default unless your run is blocked.

### Example input

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "maxItems": 1,
  "preferredLanguage": "en",
  "includeMetadata": true,
  "maxConcurrency": 1
}
````

### Example output

```json
{
  "url": "https://www.tiktok.com/@example/video/1234567890",
  "canonicalUrl": "https://www.tiktok.com/@example/video/1234567890",
  "videoId": "1234567890",
  "authorUsername": "example",
  "description": "Example public TikTok description",
  "duration": 24,
  "transcriptText": "Example caption text from the public subtitle track.",
  "segments": [
    { "startTime": 0, "endTime": 2.4, "text": "Example caption text" }
  ],
  "language": "eng-US",
  "transcriptionSource": "tiktok_captions",
  "status": "success",
  "errorReason": null,
  "scrapedAt": "2026-06-25T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Paste one or more public TikTok video URLs.
3. Set `maxItems` to a small number for your first run.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Tips for best results

- Use direct public video URLs.
- Start with 1–3 URLs to verify your workflow.
- Keep concurrency low for large batches.
- Check `status` and `errorReason` before assuming a URL has no speech.
- Some public videos do not expose public captions; these are returned as skipped rows.
- Deleted, private, region-limited, or age-restricted videos may fail or be skipped.

### Working with skipped videos

A skipped row is still useful. It means the actor processed the URL and can tell you why no transcript was returned.

Common reasons include:

- No public captions available
- Video is private or deleted
- TikTok blocked or restricted the video page
- Caption file was unavailable
- Caption file could not be parsed

### Integrations

Use this actor with:

- Google Sheets exports for manual review
- Apify webhooks for automatic notifications
- Databases such as BigQuery, Postgres, or Snowflake
- Social listening dashboards
- Content repurposing workflows
- Internal creative research tools
- Zapier or Make automations through Apify integrations

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/best-tiktok-ai-transcript-extractor').call({
  videoUrls: ['https://www.tiktok.com/@scout2015/video/6718335390845095173'],
  maxItems: 1
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/best-tiktok-ai-transcript-extractor').call(run_input={
    'videoUrls': ['https://www.tiktok.com/@scout2015/video/6718335390845095173'],
    'maxItems': 1,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~best-tiktok-ai-transcript-extractor/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"videoUrls":["https://www.tiktok.com/@scout2015/video/6718335390845095173"],"maxItems":1}'
```

### MCP usage

Connect Apify MCP to Claude Desktop, Claude Code, or other MCP clients and enable this actor as a tool.

Claude Code quick setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/best-tiktok-ai-transcript-extractor
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/best-tiktok-ai-transcript-extractor"
    }
  }
}
```

MCP example prompts:

- "Use the TikTok transcript extractor via MCP to process these video URLs and summarize the hooks."
- "Create a spreadsheet-ready table with TikTok captions, authors, hashtags, and skip reasons."
- "Check which videos in this batch have public captions available and explain failures."

### Data quality notes

Transcript availability depends on what is publicly available for each TikTok video. If a video has no public caption track, the actor returns metadata and a clear skip reason instead of fabricating transcript text.

### Legality

This actor is designed for publicly available TikTok video pages. You are responsible for using the output lawfully, respecting copyright, privacy, platform terms, and applicable regulations. Do not use extracted data for spam, harassment, impersonation, or unlawful profiling.

### Troubleshooting

#### Why is `transcriptText` empty?

The video may not expose public captions. Check `status` and `errorReason` for the exact reason.

#### Why did a URL fail?

The video may be private, deleted, age-restricted, region-limited, or temporarily blocked. Try a direct public `/video/` URL and run a small batch first.

#### Should I use a proxy?

Use the default proxy settings first. If you see repeated access errors, try Apify Proxy with a different group or region.

### FAQ

#### Can I process many TikTok URLs?

Yes. Use `videoUrls` and set `maxItems` to control the batch size.

#### Does it support all languages?

The actor can select a preferred caption language when TikTok exposes multiple public caption tracks. If the preferred language is unavailable, it uses another available track.

#### Does it download videos?

No. The dataset focuses on transcript and metadata fields.

#### Can I schedule it?

Yes. Use Apify schedules to run the actor repeatedly with updated URL lists.

### Related actors

Explore other Apify actors from the same publisher:

- https://apify.com/fetch\_cat/tiktok-profile-scraper
- https://apify.com/fetch\_cat/tiktok-hashtag-scraper
- https://apify.com/fetch\_cat/youtube-transcript-scraper
- https://apify.com/fetch\_cat/youtube-channel-videos-scraper

### Support

If you need help, open an issue on the Apify actor page and include a sample input URL, run ID, and the dataset row that did not match your expectation.

# Actor input Schema

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

Public TikTok video URLs to process. Use direct /video/ URLs for best results.

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

Optional Apify request-list compatible TikTok video URLs. Values are merged with TikTok video URLs above.

## `maxItems` (type: `integer`):

Maximum number of input URLs to process from the combined URL lists.

## `preferredLanguage` (type: `string`):

Preferred TikTok caption language code, such as en, es, de, or fr. If unavailable, the actor uses the first public caption track.

## `includeMetadata` (type: `boolean`):

Include author, description, stats, hashtags, music, duration, and publish time when TikTok exposes them publicly.

## `maxConcurrency` (type: `integer`):

How many TikTok URLs to process at the same time. Keep this low for better reliability.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy configuration. Leave disabled unless TikTok blocks your run; direct requests are cheapest and usually work for public pages.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "maxItems": 3,
  "preferredLanguage": "en",
  "includeMetadata": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "videoUrls": [
        "https://www.tiktok.com/@scout2015/video/6718335390845095173"
    ],
    "maxItems": 3,
    "preferredLanguage": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/best-tiktok-ai-transcript-extractor").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 = {
    "videoUrls": ["https://www.tiktok.com/@scout2015/video/6718335390845095173"],
    "maxItems": 3,
    "preferredLanguage": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/best-tiktok-ai-transcript-extractor").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 '{
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "maxItems": 3,
  "preferredLanguage": "en"
}' |
apify call fetch_cat/best-tiktok-ai-transcript-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok AI Transcript Extractor",
        "description": "Extract public TikTok captions, transcript text, timestamped segments, video metadata, creator details, hashtags, music, and clear skip reasons from video URLs.",
        "version": "0.1",
        "x-build-id": "NwLjxTmt1wvrVybOf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~best-tiktok-ai-transcript-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-best-tiktok-ai-transcript-extractor",
                "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/fetch_cat~best-tiktok-ai-transcript-extractor/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-best-tiktok-ai-transcript-extractor",
                "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/fetch_cat~best-tiktok-ai-transcript-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-best-tiktok-ai-transcript-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "videoUrls": {
                        "title": "TikTok video URLs",
                        "type": "array",
                        "description": "Public TikTok video URLs to process. Use direct /video/ URLs for best results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Optional Apify request-list compatible TikTok video URLs. Values are merged with TikTok video URLs above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of input URLs to process from the combined URL lists.",
                        "default": 5
                    },
                    "preferredLanguage": {
                        "title": "Preferred caption language",
                        "type": "string",
                        "description": "Preferred TikTok caption language code, such as en, es, de, or fr. If unavailable, the actor uses the first public caption track.",
                        "default": "en"
                    },
                    "includeMetadata": {
                        "title": "Include video metadata",
                        "type": "boolean",
                        "description": "Include author, description, stats, hashtags, music, duration, and publish time when TikTok exposes them publicly.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many TikTok URLs to process at the same time. Keep this low for better reliability.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. Leave disabled unless TikTok blocks your run; direct requests are cheapest and usually work for public pages.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```