# Temu Scraper (`automation-lab/temu-scraper`) Actor

Scrape Temu product listings by keyword, category, or direct URL. Extract title, price, discount, images, rating, reviews, and seller info. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/temu-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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 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

## Temu Scraper

Extract product data from [Temu](https://www.temu.com/) by keyword, category, or direct product URL. Get titles, prices, discounts, images, ratings, reviews, and seller info — no account or API key required.

### What does Temu Scraper do?

Temu Scraper is a **browser-based scraper** that navigates Temu's website like a real user to extract product listings. You provide keywords, category URLs, or product URLs — the scraper handles everything else.

**Key capabilities:**
- 🔍 **Search products** by any keyword (e.g., "wireless earbuds", "phone case", "yoga mat")
- 📂 **Browse categories** by providing Temu category URLs
- 📦 **Extract product details** from direct product page URLs
- 📊 **Get full data** — prices, discounts, images, ratings, review counts, sold counts, seller info
- ♾️ **Scroll & paginate** automatically to collect up to your specified limit

### Who is Temu Scraper for?

**🛒 E-commerce entrepreneurs & dropshippers**
- Find trending products with high sales volume and strong ratings
- Monitor competitor pricing across product categories
- Identify products with big discounts for deal-tracking apps

**📊 Market researchers & analysts**
- Track price trends on Temu for thousands of SKUs at once
- Compare Temu pricing to Amazon, AliExpress, Shein
- Build product catalogs from specific categories for comparison reports

**💹 Price monitoring & competitive intelligence teams**
- Set up scheduled Apify runs to alert on price changes
- Monitor new product launches in specific categories
- Track discount depth for retail analytics

**🤖 Developers building apps**
- Power product comparison tools with Temu data
- Build price alert services
- Create gift-finder or budget-shopping applications

### Why use Temu Scraper?

- ✅ **No account or API key needed** — works out of the box
- ✅ **Handles Temu's JavaScript rendering** — uses real browser, not simple HTTP
- ✅ **Stealth browser mode** — reduces blocks and CAPTCHAs
- ✅ **Residential proxies** — automatically rotates IPs to avoid rate limiting
- ✅ **Smart scrolling** — loads more products as it scrolls, up to your limit
- ✅ **Flexible input** — keywords, category URLs, or direct product URLs
- ✅ **Export to JSON, CSV, or Excel** — via Apify platform, no coding needed
- ✅ **Schedule runs** — monitor prices daily or weekly automatically

### What data can you extract?

| Field | Description | Example |
|-------|-------------|---------|
| `productId` | Temu product ID | `601099512665876` |
| `title` | Product name | `"Wireless Bluetooth Earbuds..."` |
| `url` | Product page URL | `https://www.temu.com/goods.html?...` |
| `price` | Current price (USD) | `12.99` |
| `originalPrice` | Pre-discount price | `29.99` |
| `discountPercent` | Discount % | `57` |
| `currency` | Currency code | `"USD"` |
| `thumbnailUrl` | Main product image URL | `https://img.kwcdn.com/...` |
| `images` | All product image URLs | `["https://img.kwcdn.com/..."]` |
| `rating` | Average star rating | `4.8` |
| `reviewCount` | Number of reviews | `1234` |
| `soldCount` | Total units sold | `5000` |
| `sellerName` | Seller/store name | `"TechGadgets Store"` |
| `shippingInfo` | Shipping type | `"Free shipping"` |
| `categoryName` | Product category | `"Electronics"` |
| `searchKeyword` | Query that found it | `"wireless earbuds"` |
| `scrapedAt` | Extraction timestamp | `"2026-04-01T12:00:00.000Z"` |

### How much does it cost to scrape Temu?

This Actor uses **pay-per-event** pricing — you pay only for products scraped.
No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per product** | $0.005 | $0.0045 | $0.0035 | $0.0027 |
| **100 products** | $0.50 | $0.45 | $0.35 | $0.27 |
| **1,000 products** | $5.02 | $4.52 | $3.52 | $2.72 |
| **10,000 products** | $50.02 | $45.02 | $35.02 | $27.02 |

Higher-tier plans get additional volume discounts.

**Real-world cost examples:**

| Input | Results | Duration | Cost (Free tier) |
|---|---|---|---|
| 1 keyword, 10 products | ~10 | ~60s | ~$0.07 |
| 1 keyword, 50 products | ~50 | ~2min | ~$0.27 |
| 3 keywords, 100 products each | ~300 | ~8min | ~$1.52 |

**On the free plan ($5 credits):** You can extract approximately 1,000 products.

### How to scrape Temu products

1. [Open Temu Scraper](https://apify.com/automation-lab/temu-scraper) on Apify Store
2. Click **Try for free**
3. Enter your search keywords (one per line, e.g., `wireless earbuds`)
4. Set **Max products per keyword** (start with 10–20 to test)
5. Click **Start** and wait for results
6. Download data as JSON, CSV, or Excel from the **Dataset** tab

**Input examples:**

Search by keyword:
```json
{
    "keywords": ["wireless earbuds", "phone stand"],
    "maxProductsPerKeyword": 50
}
````

Browse a category:

```json
{
    "categoryUrls": ["https://www.temu.com/c/electronics.html"],
    "maxProductsPerKeyword": 100
}
```

Scrape specific products:

```json
{
    "productUrls": [
        "https://www.temu.com/goods.html?_bg_fs=1&goods_id=601099512665876"
    ]
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keywords` | string\[] | no\* | `[]` | Search keywords to find products on Temu |
| `categoryUrls` | string\[] | no\* | `[]` | Temu category page URLs to browse |
| `productUrls` | string\[] | no\* | `[]` | Direct Temu product page URLs |
| `maxProductsPerKeyword` | integer | no | `50` | Max products per keyword/category (0 = unlimited) |
| `proxyConfiguration` | object | no | RESIDENTIAL | Proxy settings (residential recommended) |

\*At least one of `keywords`, `categoryUrls`, or `productUrls` is required.

### Output examples

```json
{
    "productId": "601099512665876",
    "title": "Wireless Bluetooth Earbuds with Charging Case, 30H Playtime",
    "url": "https://www.temu.com/goods.html?_bg_fs=1&goods_id=601099512665876",
    "price": 12.99,
    "originalPrice": 29.99,
    "discountPercent": 57,
    "currency": "USD",
    "thumbnailUrl": "https://img.kwcdn.com/product/fancy/...",
    "images": [
        "https://img.kwcdn.com/product/fancy/...",
        "https://img.kwcdn.com/product/fancy/..."
    ],
    "rating": 4.8,
    "reviewCount": 1234,
    "soldCount": 5000,
    "sellerName": "TechGadgets Store",
    "shippingInfo": "Free shipping",
    "categoryName": "Electronics",
    "searchKeyword": "wireless earbuds",
    "scrapedAt": "2026-04-01T12:00:00.000Z"
}
```

### Tips for best results

- **Start small** — test with `maxProductsPerKeyword: 10` first to verify results before scaling up
- **Use specific keywords** — "blue wireless earbuds under $20" returns more targeted results than "electronics"
- **Residential proxies are required** — Temu blocks datacenter IPs; the default proxy setting is optimal
- **Schedule for price monitoring** — use Apify's scheduler to run daily and track price changes
- **Combine with Google Sheets** — use the Apify → Google Sheets integration to maintain a live price tracker
- **Check soldCount** — high sold counts indicate popular/trending products worth monitoring

### Integrations

**📊 Temu → Google Sheets** for live price tracking
Use the [Apify → Google Sheets integration](https://apify.com/integrations/google-sheets) to automatically populate a spreadsheet with Temu prices. Set up a daily schedule to maintain a price history database.

**🔔 Temu → Slack alerts** for price drops
Connect to Slack via [Make](https://www.make.com/) or [Zapier](https://zapier.com/): when Temu Scraper finds a product price below your threshold, send an automatic Slack message to your team or personal channel.

**📦 Temu → AirTable** for product catalog management
Build a product database in AirTable. Run Temu Scraper weekly on categories you monitor, and use Make/Zapier to upsert records — keeping product availability and pricing current.

**🤖 Scheduled runs for competitive monitoring**
Set Temu Scraper to run every morning on your competitor's top categories. Combine with a Google Sheets integration to log prices over time and generate trend charts.

**🔗 Webhooks for real-time processing**
Configure a webhook on the run to POST dataset results to your own API endpoint as soon as each batch completes. Perfect for real-time price alert apps.

### Using the Apify API

Run Temu Scraper programmatically using the Apify API. Useful for building apps that trigger scraping on demand.

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/temu-scraper').call({
    keywords: ['wireless earbuds'],
    maxProductsPerKeyword: 50
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log('Scraped products:', items.length);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_TOKEN')

run = client.actor('automation-lab/temu-scraper').call(run_input={
    'keywords': ['wireless earbuds'],
    'maxProductsPerKeyword': 50
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Scraped {len(items)} products')
```

**cURL:**

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~temu-scraper/runs?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "keywords": ["wireless earbuds"],
    "maxProductsPerKeyword": 50
  }'
```

### Use with AI agents via MCP

Temu Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/temu-scraper to search for 'yoga mat' on Temu and return the top 20 products with their prices and ratings"
- "Scrape wireless earbuds from Temu and find the ones with rating above 4.5 and price under $15"
- "Get me the 50 best-selling phone cases from Temu and export the results to a CSV"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Temu?

Web scraping publicly accessible data is generally legal in most jurisdictions, provided you only collect data that is publicly visible (not behind a login) and comply with applicable regulations. Our scraper only accesses public product listing pages — no login, no private data.

- **Public data only** — all scraped data is visible to any visitor on temu.com
- **No authentication required** — we don't bypass any access controls
- **Respect rate limits** — the scraper uses reasonable request pacing to avoid overloading servers
- **GDPR compliant** — no personal user data is collected; only public product information
- **Your responsibility** — always consult legal counsel if you have specific compliance requirements

See Apify's [Is web scraping legal?](https://apify.com/web-scraping) guide for a comprehensive overview.

### FAQ

**How many products can I scrape per keyword?**
You can set `maxProductsPerKeyword` to any number from 1 to 1,000. For unlimited results, set it to 0 (use with caution on very broad keywords). The scraper scrolls the search results page, loading more products as it goes.

**How long does it take?**
A typical run with 1 keyword and 50 products completes in 2–3 minutes. For 100 products: 4–6 minutes. Larger runs scale proportionally.

**How does this compare to Temu's official API?**
Temu does not offer a public API for product data. This scraper is the only way to programmatically access Temu product listings at scale.

**Why do some products have null prices or ratings?**
Some product cards on Temu don't display prices until the page fully loads, or some products may not yet have ratings. The scraper captures what's visible at scrape time. Try scrolling with a higher `maxProductsPerKeyword` to get more data.

**Why am I getting fewer results than my maxProductsPerKeyword limit?**
Temu's search results for some keywords may have fewer total products than your limit. The scraper will stop when it reaches the end of the results page. For common product categories, there are typically thousands of results.

**The scraper returned 0 results — what should I try?**

1. Check your keyword spelling — try a simpler, more common term
2. Ensure `maxProductsPerKeyword` is set to at least 10
3. Try a category URL instead of a keyword
4. The proxy may have been blocked — try running again (a new residential IP will be assigned)

**Can I scrape product reviews?**
The search results page shows summary review data (rating and count). For full review text, you would need to provide direct product URLs using `productUrls` — the scraper extracts all available data from product pages.

### Other e-commerce scrapers

Looking for data from other shopping platforms? Check these automation-lab scrapers:

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — search results, products, prices, Prime eligibility
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — full reviews, ratings, and verified purchase status
- [Amazon Bestsellers Scraper](https://apify.com/automation-lab/amazon-bestsellers-scraper) — top products across Amazon categories
- [BestBuy Scraper](https://apify.com/automation-lab/bestbuy-scraper) — products, prices, and availability from BestBuy.com
- [TikTok Shop Scraper](https://apify.com/automation-lab/tiktok-shop-scraper) — TikTok Shop product listings by keyword or category

# Actor input Schema

## `keywords` (type: `array`):

Enter keywords to search Temu (e.g. "shoes", "phone case"). One keyword per line. The scraper will search each keyword and return products.

## `categoryUrls` (type: `array`):

Add Temu category page URLs (e.g. https://www.temu.com/c/electronics.html). One URL per line.

## `productUrls` (type: `array`):

Add direct Temu product page URLs for detailed extraction (e.g. https://www.temu.com/goods.html?\_bg\_fs=1\&goods\_id=601099512665876). One URL per line.

## `maxProductsPerKeyword` (type: `integer`):

Maximum number of products to extract per search keyword or category. Set to 0 for no limit.

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

Proxy settings. Residential proxies are recommended for Temu (default). Datacenter proxies may be blocked.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "categoryUrls": [],
  "productUrls": [],
  "maxProductsPerKeyword": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "keywords": [
        "wireless earbuds"
    ],
    "categoryUrls": [],
    "productUrls": [],
    "maxProductsPerKeyword": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/temu-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 = {
    "keywords": ["wireless earbuds"],
    "categoryUrls": [],
    "productUrls": [],
    "maxProductsPerKeyword": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/temu-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 '{
  "keywords": [
    "wireless earbuds"
  ],
  "categoryUrls": [],
  "productUrls": [],
  "maxProductsPerKeyword": 10
}' |
apify call automation-lab/temu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Temu Scraper",
        "description": "Scrape Temu product listings by keyword, category, or direct URL. Extract title, price, discount, images, rating, reviews, and seller info. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "YZy4ffdhaz0IeKJqY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~temu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-temu-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~temu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-temu-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~temu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-temu-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": {
                    "keywords": {
                        "title": "🔍 Search keywords",
                        "type": "array",
                        "description": "Enter keywords to search Temu (e.g. \"shoes\", \"phone case\"). One keyword per line. The scraper will search each keyword and return products.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "📂 Category URLs",
                        "type": "array",
                        "description": "Add Temu category page URLs (e.g. https://www.temu.com/c/electronics.html). One URL per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "📦 Product URLs",
                        "type": "array",
                        "description": "Add direct Temu product page URLs for detailed extraction (e.g. https://www.temu.com/goods.html?_bg_fs=1&goods_id=601099512665876). One URL per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerKeyword": {
                        "title": "Max products per keyword",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per search keyword or category. Set to 0 for no limit.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for Temu (default). Datacenter proxies may be blocked.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```