# Douyin Shop Scraper — Products, Search, Reviews (`sian.agency/douyin-shop-scraper`) Actor

Scrape Douyin Shop (抖音商城) into clean structured datasets — keyword product search, deep product details with SKUs and images, and customer reviews with ratings and photos. Three operations in one actor. No account, no API key, no setup.

- **URL**: https://apify.com/sian.agency/douyin-shop-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product comment results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Douyin Shop Scraper — Products, Search, Reviews 🚀

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Taobao Tmall Scraper](https://img.shields.io/badge/SI%C3%81N-Taobao%20%26%20Tmall-FF4F00)](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [![Xiaohongshu Scraper](https://img.shields.io/badge/SI%C3%81N-Xiaohongshu-FF2442)](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian) [![Douyin Scraper](https://img.shields.io/badge/SI%C3%81N-Douyin-161823)](https://apify.com/sian.agency/douyin-scraper?fpr=sian)

#### 🎉 The dataset layer for Douyin Shop (抖音商城) — products, reviews, and search in one clean output
##### Built for dropshippers, brand analysts, and China-market researchers who need video-commerce intelligence at scale

---

### 📋 Overview

**Tap into China's fastest-growing video-commerce platform** — Douyin Shop (抖音商城), the in-app marketplace inside Douyin (China's TikTok), powering billions in GMV from short-video and livestream commerce.

**Why thousands of professionals choose us:**
- ✅ **Three operations, one actor**: Keyword search, deep product details, and customer reviews — no juggling tools
- ⚡ **Engagement signals included**: Sales counts, comment counts, ratings, and photo evidence in every row
- 🎯 **SKU-level depth**: Full variant matrix, image gallery, video previews, and shop metadata on every product
- 💰 **Transparent per-result pricing**: Pay only for successful rows; failed lookups never charged
- 💎 **Review intelligence**: 3-axis ratings, reviewer profile, purchased SKU, and photo URLs decoded from Douyin's nested response
- ✨ **NEW**: Picture-perfect Chinese keyword support — search in 中文 returns the richest result sets

---

### ✨ Features

- 🔍 **Keyword Product Search** — Surface trending Douyin Shop SKUs by Chinese or English keyword, 10 results per page
- 🛍️ **Deep Product Detail** — SKU variants, full-resolution image galleries, video previews, button text, shop info
- 💬 **Customer Review Mining** — 20 reviews per page with star ratings, photos, reviewer handles, and purchased SKU
- 📈 **Engagement Metrics** — Live `salesCount`, `commentCount`, and shop reach signals on every product row
- 🏪 **Shop & Brand Intelligence** — Shop name, shop ID, and shop logo on every product for competitor mapping
- 🎬 **Video Preview URLs** — Direct links to Douyin Shop product videos for creative analysis
- 🇨🇳 **Native Chinese Keyword Support** — Best results when querying in 中文 (try 口红, 手机, 茅台)
- 🧾 **CNY Yuan Price Normalization** — Order snapshot prices auto-converted from cents to yuan for clean analytics
- 📦 **Clean Dataset Output** — JSON, CSV, Excel — export-ready columns, no parsing required

---

### 🎬 Quick Start

Pick one operation, give it a keyword or a `productId`, and run. Every row lands in the Apify dataset with both the curated camelCase fields and the raw upstream payload.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~douyin-shop-scraper/runs?token=YOUR_TOKEN \
-H "Content-Type: application/json" \
-d '{"operation": "searchItem", "keyword": "口红", "maxPages": 1}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick your operation

Choose **Product Search**, **Product Detail**, or **Product Comments** from the dropdown.

#### Step 2: Provide the input

Keyword (for Search) or `itemId` (for Detail / Comments). Set `maxPages` for paginated ops.

#### Step 3: Run and download

Hit Start. In under a minute, your dataset is ready in JSON, CSV, or Excel.

**That's it! In ~60 seconds, you'll have:**

- Trending product SKUs with sales + comment counts
- Full SKU variants, images, and shop metadata
- Customer reviews with star ratings and photos

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | enum | Yes | `searchItem`, `itemDetail`, or `itemComments` |
| keyword | string | If `searchItem` | Search query — Chinese gives best results (e.g. 口红, 手机) |
| itemId | string | If `itemDetail` / `itemComments` | Douyin Shop product ID (19-digit numeric) |
| maxPages | integer | No | Max pages for paginated ops (default 5, range 1–50) |

**Example — Product Search:**

```json
{
  "operation": "searchItem",
  "keyword": "口红",
  "maxPages": 3
}
```

**Example — Product Detail:**

```json
{
  "operation": "itemDetail",
  "itemId": "3715537304073404545"
}
```

**Example — Product Comments:**

```json
{
  "operation": "itemComments",
  "itemId": "3715537304073404545",
  "maxPages": 5
}
```

> 💡 **Tip on prices:** Douyin Shop masks raw prices on the **Product Detail** endpoint as an anti-scraping countermeasure (`priceMasked: true`). Use **Product Search** to capture real-world price signals and engagement, then drill into Detail for SKU variants, images, and shop metadata.

***

### 📤 Output

Results are saved to the Apify dataset with **40+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| productId | string | Douyin Shop product ID |
| productTitle | string | Product display title |
| displayPrice | string | Price as shown on Douyin Shop (masked on Detail) |
| priceMasked | boolean | True when upstream returns `?` placeholder |
| salesCount | number | Lifetime units sold |
| commentCount | number | Total customer reviews on this product |
| shopId | string | Seller shop ID |
| shopName | string | Seller shop name |
| shopLogo | string | Seller shop logo URL |
| thumbImage | string | Primary thumbnail URL |
| imageList | array | Full gallery image URLs |
| videoList | array | Product video preview URLs |
| sellPoints | array | Marketing bullet points (Chinese) |
| tags | array | Category/feature tags |
| skuInfo | object | SKU variant matrix |
| reviewRating | number | Per-comment 5-star rating |
| reviewText | string | Review body |
| reviewImages | array | Customer-uploaded photo URLs |
| reviewerName | string | Reviewer handle |
| reviewOrderSkuPrice | number | Purchased SKU price in CNY yuan |
| reviewProductName | string | Decoded product name from review payload |

**Example row (truncated):**

```json
{
  "operation": "searchItem",
  "productId": "3715537304073404545",
  "productTitle": "口红礼盒套装",
  "displayPrice": "¥89",
  "salesCount": 12480,
  "commentCount": 3421,
  "shopId": "78001234",
  "shopName": "美妆旗舰店",
  "thumbImage": "https://...",
  "videoList": ["https://..."],
  "sellPoints": ["顺丰包邮", "正品保障"],
  "scrapedAt": "2026-05-15T14:38:22.000Z"
}
```

***

### 💼 Use Cases & Examples

#### 1. Dropshipping Product Sourcing

**Dropshippers and DTC brands hunting trending SKUs on Douyin Shop**

**Input:** Keyword like 美妆, 手机壳, or 茅台
**Output:** Top SKUs ranked by sales + comment count, with shop info and video previews
**Use:** Validate product-market fit before launching on Shopify, Amazon, or TikTok Shop

#### 2. Brand & Competitor Intelligence

**Analysts mapping a competitor's presence across 抖音商城**

**Input:** Brand-name keyword, then drill into each product's `shopId`
**Output:** Shop coverage, SKU breadth, pricing tiers, customer sentiment
**Use:** Build competitor dashboards, identify pricing gaps, monitor new launches

#### 3. Customer Review Mining

**UX researchers and brand managers extracting voice-of-customer at scale**

**Input:** Product `itemId`
**Output:** 20 reviews per page with star ratings, photos, purchased SKU, and full text
**Use:** Power sentiment analysis, identify quality complaints, surface viral product moments

#### 4. China-Market Video-Commerce Research

**Market researchers tracking China's video-commerce trends**

**Input:** Category keywords (服装, 食品, 美妆) across daily scheduled runs
**Output:** Time-series of trending SKUs, shops, and engagement signals
**Use:** Quarterly trend reports, investor briefings, GMV forecasting

#### 5. Aggregator & Comparison Catalogs

**Product comparison sites and price aggregators building Chinese-market catalogs**

**Input:** Long keyword lists run in parallel
**Output:** Normalized product rows with SKU, images, shop, and engagement
**Use:** Populate comparison engines, affiliate catalogs, or B2B sourcing platforms

#### 6. Influencer & KOL Marketing

**Influencer marketers identifying KOL-driven hot products on Douyin Shop**

**Input:** Trending hashtag-style keywords or shop IDs from creator partnerships
**Output:** Products with sales velocity + review signals tied to creator campaigns
**Use:** ROI tracking for KOL deals, identify breakout SKUs, brief future campaigns

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/douyin-shop-scraper').call({
  operation: 'searchItem',
  keyword: '口红',
  maxPages: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/douyin-shop-scraper').call(
    run_input={'operation': 'itemComments', 'itemId': '3715537304073404545', 'maxPages': 5}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~douyin-shop-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "itemDetail", "itemId": "3715537304073404545"}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule daily, or webhook from a Notion/Airtable keyword list
2. **HTTP Request**: Call the actor API with operation + keyword/itemId
3. **Process**: Parse JSON rows; join `productId` to your warehouse table
4. **Action**: Push to BigQuery, Snowflake, or a Slack alert on new top SKUs

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **Generous starter allowance** — full feature access, every operation, no credit card
- Same data quality as PAID, same Chinese keyword coverage
- Perfect for prototyping, single-product audits, or evaluating fit

#### PAID Tier (Production Ready)

- **Unlimited rows per run** across all three operations
- Faster processing, priority routing, no soft caps
- Pay-per-result: charged only for successful rows — failed lookups are free

💰 **Transparent pricing** — search rows are the cheapest (the headline rate); deep product details are priced higher to reflect the SKU-level richness; comments sit between the two.

🔗 [View current pricing](https://apify.com/sian.agency/douyin-shop-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: Why are prices showing as `?` on Product Detail rows?**
A: Douyin Shop masks raw prices on its product detail endpoint as an anti-scraping countermeasure. Use **Product Search** rows for real price signals — `displayPrice` is populated there. The `priceMasked: true` flag tells you when this is happening.

**Q: How do I get a product `itemId`?**
A: Run a **Product Search** first — every result row contains `productId`. You can also extract it from any Douyin Shop product URL.

**Q: Does it work with English keywords?**
A: Yes, but Chinese keywords (中文) return far richer result sets — Douyin Shop is a China-domestic marketplace. Try 口红, 手机, or 茅台 for the cleanest demos.

**Q: How many reviews per product?**
A: Up to 20 per page, paginated. Set `maxPages` to fetch up to 1,000 reviews per product.

**Q: What output formats are available?**
A: JSON, CSV, Excel, XML, RSS — export directly from the Apify dataset.

**Q: Is this legal?**
A: We only extract publicly available product and review data. See the [legal section](#-is-it-legal-to-scrape-data) below.

**Q: How long does a typical run take?**
A: Single product detail: ~2 seconds. 5 pages of search results: ~15 seconds. 10 pages of comments: ~25 seconds.

***

### 🐛 Troubleshooting

**Empty result set on `searchItem`**

- Try the Chinese form of your keyword (中文 returns more rows)
- Lower-volume English keywords sometimes return zero results — switch to a related Chinese term

**`priceMasked: true` on every Product Detail row**

- This is by design — Douyin Shop's anti-scrape behavior. Run **Product Search** for the same `productId` to capture the real `displayPrice`

**Run errors with code 301 ("FAILED, RETRY")**

- Transient upstream hiccup — retry the run. Built-in backoff usually resolves it inside the same run.

**Comment rows missing `reviewProductName`**

- Some reviews omit the embedded product snapshot. The base review fields (rating, text, photos) are always present.

***

### ⚠️ Trademark Disclaimer

This is an **independent scraping tool**. It is not affiliated with, endorsed by, or sponsored by Douyin, ByteDance Ltd., Jinritemai (抖音电商), or any of their subsidiaries. The names **Douyin®**, **抖音®**, and **抖音商城®** appear under nominative fair use solely to identify the public platform whose openly visible product data this tool extracts. All trademarks remain the property of their respective owners.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

Pick what you want to scrape. Each run does one operation.

## `keyword` (type: `string`):

Search query. Chinese gives best results (try 口红, 手机, 茅台, 牛仔裤). Required for Product Search.

## `itemId` (type: `string`):

The numeric Douyin Shop product ID. Find it in any product URL or in the `productId` / `itemId` field of any search row. Required for Product Detail and Product Comments.

## `maxPages` (type: `integer`):

Max pages to scrape. Applies only to paginated operations (Product Search, Product Comments). Default 5. Range 1-50.

## Actor input object example

```json
{
  "operation": "searchItem",
  "keyword": "口红",
  "itemId": "3715537304073404545",
  "maxPages": 5
}
```

# Actor output Schema

## `output` (type: `string`):

Products, search results, or customer reviews — one flat row per upstream item with curated camelCase aliases (itemId, productTitle, priceDisplay, shopName, salesText, commentCount, ...) plus the raw upstream fields spread alongside.

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, pages fetched, duration, and the inputs used — written even on fatal crash.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/douyin-shop-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/douyin-shop-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 '{}' |
apify call sian.agency/douyin-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Douyin Shop Scraper — Products, Search, Reviews",
        "description": "Scrape Douyin Shop (抖音商城) into clean structured datasets — keyword product search, deep product details with SKUs and images, and customer reviews with ratings and photos. Three operations in one actor. No account, no API key, no setup.",
        "version": "1.1",
        "x-build-id": "hK56GHeehLolvfwtQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~douyin-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-douyin-shop-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/sian.agency~douyin-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-douyin-shop-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/sian.agency~douyin-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-douyin-shop-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": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "searchItem",
                            "itemDetail",
                            "itemComments"
                        ],
                        "type": "string",
                        "description": "Pick what you want to scrape. Each run does one operation.",
                        "default": "searchItem"
                    },
                    "keyword": {
                        "title": "Search Keyword (for Product Search)",
                        "type": "string",
                        "description": "Search query. Chinese gives best results (try 口红, 手机, 茅台, 牛仔裤). Required for Product Search."
                    },
                    "itemId": {
                        "title": "Item ID (for Product Detail / Comments)",
                        "type": "string",
                        "description": "The numeric Douyin Shop product ID. Find it in any product URL or in the `productId` / `itemId` field of any search row. Required for Product Detail and Product Comments."
                    },
                    "maxPages": {
                        "title": "Max pages (for paginated operations)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Max pages to scrape. Applies only to paginated operations (Product Search, Product Comments). Default 5. Range 1-50.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
