# Kwai Trending Videos Scraper (`automation-lab/kwai-trending-videos-scraper`) Actor

Export public Kwai For You videos, creators, captions, hashtags, engagement counts, posters, and available MP4 URLs without logging in.

- **URL**: https://apify.com/automation-lab/kwai-trending-videos-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Videos, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Kwai Trending Videos Scraper

Export the public **Kwai For You feed** into clean, analysis-ready data.

No Kwai login is required.

Collect creator names, captions, hashtags, likes, comments, posters, avatars, and available direct MP4 URLs.

Use repeated snapshots to see which videos, creators, and topics are surfacing now.

> This Actor supports the anonymous `https://www.kwai.com/` For You feed in v1. It does not claim to scrape profiles, search results, or comment threads.

### What does Kwai Trending Videos Scraper do?

Kwai Trending Videos Scraper opens the public Kwai home feed in a real browser.

It waits for rendered video cards and scrolls the feed container.

For each unique card it exports:

- 🎬 the Kwai video ID;
- 👤 the public creator name and avatar URL;
- 📝 the caption and a normalized hashtag list;
- ❤️ displayed likes normalized to an integer;
- 💬 displayed comments normalized to an integer;
- 🖼️ the poster or cover URL when rendered;
- 📹 a direct MP4 URL when Kwai loads it;
- 📍 the discovery position in the current snapshot;
- 🕐 an ISO scrape timestamp.

The Actor stops at your item or scroll limit and removes duplicates by video ID.

### Why use this Kwai scraper?

Kwai is highly dynamic and its feed records are rendered in the browser.

Copying cards manually is slow and produces inconsistent data.

This Actor turns the visible feed into a stable dataset that can be exported or automated.

Key benefits include:

- ✅ anonymous feed collection without account credentials;
- ✅ compact `3.5K`-style counters converted to numbers;
- ✅ bounded scrolling for predictable runs;
- ✅ one clean row per unique public video;
- ✅ JSON, CSV, Excel, XML, RSS, API, and webhook access;
- ✅ scheduling for repeat trend snapshots.

### Who is it for?

#### Social-listening teams

Capture periodic feed snapshots and compare hashtags, creators, and engagement.

#### Marketing agencies

Build evidence for campaign briefs and creator shortlists.

#### Creator researchers

Discover public videos and creators appearing in the anonymous For You experience.

#### Regional trend analysts

Track the mix of topics and creators exposed by Kwai over time.

#### Data engineers

Send structured Kwai feed rows into a warehouse, dashboard, or monitoring pipeline.

### What Kwai data can you extract?

| Field | Type | Description |
| --- | --- | --- |
| `videoId` | string | Numeric Kwai card identifier |
| `creatorName` | string | Public creator display name |
| `caption` | string | Rendered caption text |
| `hashtags` | string[] | Unique hashtags found in the caption |
| `likeCount` | integer | Displayed likes normalized from compact notation |
| `commentCount` | integer | Displayed comments normalized from compact notation |
| `avatarUrl` | URL | Creator avatar when rendered |
| `posterUrl` | URL | Video cover or poster when rendered |
| `videoUrl` | URL | Direct MP4 when the card media loads |
| `feedPosition` | integer | One-based discovery order for this run |
| `sourceUrl` | URL | Public Kwai feed URL |
| `scrapedAt` | datetime | Collection timestamp in ISO 8601 format |

Lazy media fields are optional because Kwai may not load every asset immediately.

Core identity, creator, caption, engagement, position, source, and time fields are always present on saved rows.

### How to scrape Kwai trending videos

1. Open the Actor input page.
2. Set **Maximum videos** to the snapshot size you need.
3. Keep the default scroll limit for a small run.
4. Leave proxy disabled unless your region receives an empty or challenged feed.
5. Click **Start**.
6. Review the dataset while the run is active or after it finishes.
7. Export results or connect the dataset to your workflow.

A 10-video prefilled run is the recommended first test.

### Input parameters

| Parameter | Default | Range | Purpose |
| --- | ---: | ---: | --- |
| `maxItems` | 10 | 1–500 | Maximum unique videos to save |
| `maxScrolls` | 10 | 0–100 | Maximum feed-container scrolls |
| `scrollDelayMs` | 1500 | 250–10000 | Wait for cards after each scroll |
| `proxyConfiguration` | off | — | Optional Apify or custom proxy |

All parameters are optional.

The defaults form a complete anonymous feed workflow.

For larger snapshots, increase both `maxItems` and `maxScrolls`.

### Example input

```json
{
  "maxItems": 25,
  "maxScrolls": 12,
  "scrollDelayMs": 1800
}
````

Example with Apify Proxy enabled:

```json
{
  "maxItems": 25,
  "maxScrolls": 12,
  "scrollDelayMs": 1800,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Start without a proxy to minimize cost.

Use a proxy only if logs report an empty or challenged feed.

### Example output

```json
{
  "videoId": "5219259128321585569",
  "creatorName": "Iris.emcena",
  "caption": "Grávida tá certa ? #telekwai",
  "hashtags": ["#telekwai"],
  "likeCount": 787,
  "commentCount": 42,
  "avatarUrl": "https://aws-br-pic.kwai.net/...jpg",
  "posterUrl": "https://p15-kimg.kwai.net/...webp",
  "videoUrl": "https://aws-br-cdn.kwai.net/...mp4",
  "feedPosition": 1,
  "sourceUrl": "https://www.kwai.com/",
  "scrapedAt": "2026-07-24T04:30:00.000Z"
}
```

URLs are shown shortened here only for readability.

Actual dataset rows contain complete URLs.

### How much does it cost to scrape Kwai videos?

This Actor uses pay-per-event pricing.

A small start event covers browser startup.

A per-video event is charged only for rows saved to the dataset.

The current BRONZE rate is **$0.00016872 per video** plus a **$0.001 run start**.

At that rate:

- 10 videos cost about $0.0027;
- 25 videos cost about $0.0052;
- 100 videos cost about $0.0179.

Higher Apify plans receive automatic volume discounts shown on the pricing tab.

Apify Free plan credits can be used for initial snapshots.

Proxy traffic, when enabled, is billed by Apify according to your account plan.

### Trend-monitoring workflow

Run the Actor on a schedule, such as every hour or every day.

Store each run timestamp with its video IDs and engagement values.

In your database or spreadsheet:

1. join rows by `videoId`;
2. compare `likeCount` and `commentCount` between snapshots;
3. rank engagement changes;
4. group rising rows by `hashtags` or `creatorName`;
5. alert when a creator or topic crosses your threshold.

Feed personalization and regional variation mean snapshots should be interpreted as observations, not a global Kwai chart.

### Tips for reliable Kwai extraction

- Start with 10–25 videos.
- Keep `scrollDelayMs` between 1500 and 2500 for larger snapshots.
- Increase `maxScrolls` when `maxItems` is much larger than the initial feed.
- Use the same scheduling and proxy setup when comparing snapshots.
- Treat direct MP4 URLs as temporary CDN links.
- Download or process media promptly if your workflow depends on it.
- Inspect logs before adding a residential proxy.
- Avoid many concurrent browser runs from the same region.

### Scheduling and automation

Use Apify Schedules to run snapshots automatically.

A daily schedule is useful for broad topic monitoring.

An hourly schedule is useful for fast campaign or creator research.

Attach a webhook to receive the dataset ID after each successful run.

Keep historical datasets when you need change-over-time analysis.

Use retention settings that match your compliance and reporting needs.

### Integrations

#### Google Sheets

Export each snapshot to a worksheet and build pivots by hashtag or creator.

#### Make

Trigger the Actor, filter videos by engagement, and send selected rows to Slack or Airtable.

#### Zapier

Start a run from a campaign workflow and create follow-up tasks for rising creators.

#### Webhooks

Send successful-run events to your own API and load rows by dataset ID.

#### Data warehouses

Pull JSON through the dataset API into BigQuery, Snowflake, PostgreSQL, or DuckDB.

#### LLM workflows

Send captions and hashtags to a classifier after collection rather than loading video media into the model.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kwai-trending-videos-scraper').call({
  maxItems: 25,
  maxScrolls: 12,
  scrollDelayMs: 1800,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

Never commit your Apify token to source control.

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/kwai-trending-videos-scraper').call(run_input={
    'maxItems': 25,
    'maxScrolls': 12,
    'scrollDelayMs': 1800,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~kwai-trending-videos-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":25,"maxScrolls":12,"scrollDelayMs":1800}'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use Kwai data through MCP

Connect this Actor to Claude Code with the hosted Apify MCP server:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/kwai-trending-videos-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/kwai-trending-videos-scraper"
    }
  }
}
```

Example prompts:

- “Run a 25-video Kwai For You snapshot and summarize the top hashtags.”
- “Collect 50 Kwai feed videos and rank creators by visible likes.”
- “Compare this Kwai snapshot with yesterday’s dataset by video ID.”

You need an Apify account and token for authenticated MCP tool use.

### Data quality and normalization

Kwai displays some counters in compact notation.

The Actor converts values such as `3.5K` to `3500` and `1.2M` to `1200000`.

Hashtags are deduplicated within each caption.

Cards without a numeric ID or creator name are skipped.

Duplicate cards are removed by `videoId` within the current run.

Feed positions represent discovery order, not an official global ranking.

### Limitations

The public For You feed can vary by time, session, region, and Kwai experiments.

This Actor does not authenticate to Kwai.

It does not scrape profile pages, keyword search, comments, followers, or private data.

It does not guarantee that every card exposes a direct MP4 URL.

Kwai CDN URLs can expire.

A website redesign may require selector updates.

The Actor fails rather than returning a misleading successful empty dataset.

### Privacy and legal considerations

This Actor collects data rendered publicly on Kwai.

You are responsible for your purpose, lawful basis, retention, and downstream use.

Review Kwai terms and applicable laws before running recurring collection.

Do not use the output to harass creators, infer sensitive traits, or build prohibited profiles.

Avoid redistributing copyrighted media without permission.

Minimize personal data and delete it when it is no longer needed.

This documentation is not legal advice.

### Troubleshooting

#### Why did the run return an empty-feed error?

Kwai may have throttled or challenged the browser session.

Retry once with an Apify Proxy configuration and a conservative item limit.

If the problem persists, inspect the log for navigation or selector errors.

#### Why is `videoUrl` missing?

Kwai loads video media lazily.

Poster and metadata fields can be available before a card’s MP4 is attached.

Increase `scrollDelayMs` modestly, but do not assume every card will expose media.

#### Why did I receive fewer videos than requested?

The run may have reached `maxScrolls` or stopped after two scrolls without new IDs.

Increase `maxScrolls` and keep a reasonable scroll delay.

#### Why do two scheduled runs show different feeds?

The For You surface is dynamic and may vary by session or region.

Use snapshots as observed trend samples rather than an exhaustive global ranking.

### Frequently asked questions

#### Does this Kwai scraper require login?

No. v1 uses the anonymous public For You feed.

#### Can it scrape a creator profile or video URL?

No. Those input modes are intentionally outside the verified v1 scope.

#### Can I download videos?

The dataset includes a direct MP4 URL when Kwai loads one.

You must handle copyright, storage, and link expiry in your own workflow.

#### Are likes and comments numeric?

Yes. Displayed compact counters are normalized to integers.

#### Can I run it on a schedule?

Yes. Apify Schedules are ideal for repeated feed snapshots.

#### Is the feed a global trending chart?

No. It is the anonymous For You feed observed by the current browser session.

### Related social media scrapers

Extend your public social-data workflow with other Automation Lab Actors:

- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper)
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper)
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper)
- [Douyin Scraper](https://apify.com/automation-lab/douyin-scraper)

Choose this Actor when the required source is specifically the anonymous Kwai For You feed.

### Support

If a run fails, include the run ID, input, approximate time, and whether a proxy was enabled.

Do not include account passwords, cookies, or private tokens.

Clear reproduction details help distinguish a Kwai page change from a regional delivery issue.

For feature requests, describe the exact public page and fields you need.

Profile, search, and comments are not implied by the current product scope.

# Actor input Schema

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

Stop after saving this many unique public Kwai videos.

## `maxScrolls` (type: `integer`):

Limit how many times the Actor scrolls the For You feed. Increase this only when requesting more videos.

## `scrollDelayMs` (type: `integer`):

Wait this many milliseconds for newly rendered video cards after each scroll.

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

Optionally route the browser through Apify Proxy. Start without a proxy; use residential sessions only if Kwai returns an empty or challenged feed.

## Actor input object example

```json
{
  "maxItems": 10,
  "maxScrolls": 10,
  "scrollDelayMs": 1500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the structured video dataset with creator, caption, hashtags, engagement, media, feed position, and collection time fields.

# 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 = {
    "maxItems": 10,
    "maxScrolls": 10,
    "scrollDelayMs": 1500,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/kwai-trending-videos-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 = {
    "maxItems": 10,
    "maxScrolls": 10,
    "scrollDelayMs": 1500,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kwai-trending-videos-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 '{
  "maxItems": 10,
  "maxScrolls": 10,
  "scrollDelayMs": 1500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/kwai-trending-videos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/kwai-trending-videos-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kwai Trending Videos Scraper",
        "description": "Export public Kwai For You videos, creators, captions, hashtags, engagement counts, posters, and available MP4 URLs without logging in.",
        "version": "0.1",
        "x-build-id": "eT2Q8GfxcgwbtjZGY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kwai-trending-videos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-kwai-trending-videos-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/automation-lab~kwai-trending-videos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-kwai-trending-videos-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/automation-lab~kwai-trending-videos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-kwai-trending-videos-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",
                "properties": {
                    "maxItems": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after saving this many unique public Kwai videos.",
                        "default": 10
                    },
                    "maxScrolls": {
                        "title": "Maximum feed scrolls",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit how many times the Actor scrolls the For You feed. Increase this only when requesting more videos.",
                        "default": 10
                    },
                    "scrollDelayMs": {
                        "title": "Delay after each scroll (ms)",
                        "minimum": 250,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Wait this many milliseconds for newly rendered video cards after each scroll.",
                        "default": 1500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optionally route the browser through Apify Proxy. Start without a proxy; use residential sessions only if Kwai returns an empty or challenged feed.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
