# AliExpress Review Scraper (`sourabhbgp/aliexpress-review-scraper`) Actor

Scrape every review from any AliExpress product by URL or ID: star ratings, original and translated text in 16 languages, buyer country, the variant bought, aspect tags, and buyer photos. Export to JSON, CSV, or Excel. $2.50 per 1,000 reviews.

- **URL**: https://apify.com/sourabhbgp/aliexpress-review-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### AliExpress review scraper: all reviews, translated, with photos & ratings

Pull every review for any AliExpress product: the buyer's original text, a clean translation, the star rating, the variant they bought, photos, and helpful votes. A per-product rating summary is reported in the run log.

**$2.50 per 1,000 reviews. You only pay for review rows. No proxy or browser setup needed.**

A product's reviews arrive from buyers worldwide in a mix of languages, so this actor returns them all in one language you choose (English by default), with each buyer's original text always kept. Export to JSON, CSV, or Excel.

### Why this scraper?

- 💬 **Deep pagination, not just the first page**: every review the product exposes, up to AliExpress's own per-product cap of about 5,000 (most products have far fewer, so you get them all).
- 🌍 **One readable language out of many**: a product's reviews come in mixed languages, so you get them all in one (English by default, 16 to choose from), original always kept.
- 📊 **Per-product rating summary in the log**: average score, total and scraped counts, positive/neutral/negative split, the full 1 to 5 star breakdown, and AliExpress's own AI review highlights, written to the run log at no charge.
- 📸 **Photo reviews on demand**: flip one switch to pull only reviews that include buyer photos; full-size and thumbnail URLs both returned.
- 🧾 **Rich per-review data**: buyer country and gender, the exact variant bought, shipping method, structured aspect tags, follow-up reviews, an AI-generated flag, and up/down votes.
- 💵 **Cheap and predictable**: flat $2.50 per 1,000 reviews; you only pay for review rows.
- ⚡ **Fast and reliable**: plain HTTP, no headless browser, no flaky proxy juggling.
- 🆔 **Dead-simple input**: a product URL or a bare ID both work, and duplicates are billed once.

### What data can you extract?

<table>
<tr><td>⭐ Star rating (1 to 5)</td><td>💬 Original review text</td><td>🌐 Translated text</td><td>🗓️ Review date</td></tr>
<tr><td>🌍 Buyer country</td><td>👤 Buyer name</td><td>🎨 Variant bought (SKU)</td><td>🚚 Shipping method</td></tr>
<tr><td>📸 Review photos + thumbnails</td><td>👍 Helpful up-votes</td><td>👎 Down-votes</td><td>🔁 Follow-up review</td></tr>
<tr><td>🏷️ Aspect tags</td><td>🧑 Buyer gender</td><td>🤖 AI-generated flag</td><td>🕵️ Anonymous flag</td></tr>
<tr><td>📈 Average rating</td><td>🔢 Total + scraped counts</td><td>📊 Star distribution</td><td>✨ AI review highlights</td></tr>
</table>

Each run returns exactly one row per review, so the dataset's result count equals the number of reviews you scrape and are billed for. A per-product rating breakdown (average, star distribution, AI highlights) is written to the run log, not the dataset.

### Scrape AliExpress reviews in 16 languages

A single AliExpress product collects reviews from buyers all over the world, so they arrive in a mix of languages that is hard to read or analyze. This actor fixes that: it returns every review in one language you choose, English by default, and always keeps the buyer's original text in `reviewTextOriginal`. Set the `language` field to any of these 16:

| Language | Code | | Language | Code |
|---|---|---|---|---|
| English | `en_US` | | Polish | `pl_PL` |
| Spanish | `es_ES` | | Dutch | `nl_NL` |
| Portuguese | `pt_BR` | | Japanese | `ja_JP` |
| Russian | `ru_RU` | | Korean | `ko_KR` |
| French | `fr_FR` | | Arabic | `ar_MA` |
| German | `de_DE` | | Thai | `th_TH` |
| Italian | `it_IT` | | Vietnamese | `vi_VN` |
| Turkish | `tr_TR` | | Indonesian | `id_ID` |

So you can scrape AliExpress reviews in Spanish, pull AliExpress reviews in English, get reviews in French, German, Portuguese, or Russian, and read them in Japanese, Korean, Arabic, Thai, or Italian, all from one actor.

**AliExpress reviews in Spanish:**

```json
{ "productUrls": ["https://www.aliexpress.com/item/3256811621288203.html"], "language": "es_ES" }
````

**AliExpress reviews in Russian:**

```json
{ "productUrls": ["https://www.aliexpress.com/item/3256811621288203.html"], "language": "ru_RU" }
```

**What about Chinese reviews?** Chinese is not a translation target on AliExpress's global site, so you can't translate reviews into Chinese. But reviews written by Chinese-speaking buyers come back in their original Chinese in `reviewTextOriginal`, untouched. You capture every Chinese review, you just read it as-written.

**Native script kept as-is.** `reviewTextOriginal` preserves each review exactly as the buyer typed it: Chinese, Korean, Arabic, Cyrillic, Thai, even emoji, all unchanged. `reviewTextTranslated` carries the chosen-language version next to it, so you get both in every row.

### How to scrape AliExpress reviews: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [AliExpress Review Scraper](https://console.apify.com/actors/XeaaHYrAd8X1gszeD?addFromActorId=XeaaHYrAd8X1gszeD) in the Apify Console.
3. Paste one or more AliExpress product URLs (or numeric product IDs).
4. Click **Start**. Most runs finish in well under a minute per product.
5. Export as JSON, CSV, or Excel, or pull the results via API.

### How much does AliExpress Review Scraper cost?

You pay **$2.50 per 1,000 reviews**. The Apify Free plan includes $5 of monthly credits, enough for roughly 2,000 reviews. The $29/month Starter plan covers about 11,600 reviews a month. You are charged only for review rows, the run-start fee is a negligible $0.001, and the run's result count equals exactly what you pay for. Compute for this HTTP-only actor is tiny, typically a few cents per thousand reviews.

### Input

```json
{
  "productUrls": [
    "https://www.aliexpress.com/item/3256811621288203.html",
    "1005006401040219"
  ],
  "maxReviewsPerProduct": 100,
  "language": "en_US",
  "country": "US",
  "withPhotosOnly": false,
  "maxConcurrency": 8
}
```

| Field | Type | Default | Note |
|---|---|---|---|
| `productUrls` | array | (required) | AliExpress product URLs or bare numeric product IDs. |
| `maxReviewsPerProduct` | integer | 100 | Cap per product. Use 0 for all reviews. |
| `language` | string | `en_US` | Translation target: `en_US`, `es_ES`, `pt_BR`, `ru_RU`, `fr_FR`, `de_DE`, `it_IT`, `tr_TR`, `pl_PL`, `nl_NL`, `ja_JP`, `ko_KR`, `ar_MA`, `th_TH`, `vi_VN`, or `id_ID`. |
| `country` | string | `US` | Review locale context. |
| `withPhotosOnly` | boolean | false | Return only reviews that include buyer photos. |
| `maxConcurrency` | integer | 8 | How many products to scrape in parallel (1 to 20). |

### Output

A review row:

```json
{
  "productId": "3256811621288203",
  "reviewId": "60096451623486425",
  "rating": 5,
  "reviewTextOriginal": "Exactly as described. Decent sound. Stable connection. 3-4hr battery life.",
  "reviewTextTranslated": "Exactly as described. Decent sound. Stable connection. 3-4hr battery life.",
  "followUpReview": null,
  "followUpAfterDays": null,
  "reviewAspects": [
    { "label": "Quality of sound", "value": "Fast" },
    { "label": "Durability", "value": "Good" }
  ],
  "buyerName": "j***i",
  "buyerCountry": "US",
  "buyerGender": "M",
  "anonymous": false,
  "reviewDate": "07 Apr 2026",
  "skuInfo": "Color:Blackpods A7",
  "logistics": "AliExpress Standard Shipping",
  "upVotes": 0,
  "downVotes": 0,
  "aiGenerated": false,
  "photos": ["https://ae-pic-a1.aliexpress-media.com/kf/A498cf0fdf.jpg"],
  "photoThumbnails": ["https://ae-pic-a1.aliexpress-media.com/kf/A498cf0fdf.jpg_220x220.jpg"]
}
```

Per product, a rating summary is written to the run log (not the dataset, so it never
counts as a result): average rating, total vs scraped review counts, positive/neutral/negative
split, the 1 to 5 star breakdown, photo-review count, and AliExpress's own AI review
highlights (for example "good value for price" mentioned 19 times).

If a product URL can't be read, it is skipped and noted in the run log, and the run keeps going.

### Use cases

- 🛒 **Dropshipping sourcing**: judge supplier quality from real ratings, order experience, and photos before you commit.
- 📊 **Product research**: compare review volume and sentiment across competing listings.
- 😀 **Sentiment analysis**: feed thousands of reviews into your own model with consistent, translated text.
- 🌍 **Multilingual aggregation**: collect reviews from buyers worldwide and read them all in one language.
- 🔍 **Quality and complaint mining**: pull photo reviews and low-star feedback to spot defects fast.
- 📈 **Competitive benchmarking**: track a rival product's average rating and star spread over time.
- 🤖 **AI training data**: build clean, multilingual review datasets with original and translated pairs.

### Limitations

- **Chinese is not a translation target.** AliExpress does not translate reviews into Chinese, so `reviewTextTranslated` falls back to the source there. Native Chinese reviews still come through in Chinese in `reviewTextOriginal`.
- **Buyer names are masked.** AliExpress shows names like `j***i`, so full names are never available.
- **No star-level filter.** The source has no server-side rating filter, so you get all ratings; filter by the `rating` field yourself if you need a single band.
- **About 5,000 reviews per product.** AliExpress's review endpoint stops serving new reviews past roughly 5,000 per product, returning its most relevant subset. Most products have far fewer and come back complete; for very popular listings, the run-log summary shows `scrapedReviews` against `totalReviews` so you can see how many were available.
- **Public reviews only.** The actor reads what any logged-out shopper can see, nothing private.
- **Translations are machine-generated.** They come from AliExpress, so quality varies by language and phrasing.

### FAQ

#### How much does AliExpress Review Scraper cost?

It uses pay-per-result pricing. You pay **$2.50 for 1,000 reviews**. The Apify Free plan gives you $5 in usage credits a month, enough for around 2,000 reviews. If you run regularly, the $29/month Starter plan covers about 11,600 reviews. You only pay for review rows, so the result count is exactly what you are billed for, and there's no subscription lock-in.

#### What languages does AliExpress Review Scraper support?

It translates reviews into 16 languages: English, Spanish, Portuguese, Russian, French, German, Italian, Turkish, Polish, Dutch, Japanese, Korean, Arabic, Thai, Vietnamese, and Indonesian. The buyer's original-language text is always included too. Chinese is not a translation target, but reviews written in Chinese are returned unchanged in their original Chinese.

#### Can I scrape AliExpress reviews in Spanish, French, or another language?

Yes. Set the `language` field to the language you want (for example `es_ES` for Spanish or `fr_FR` for French) and every review's `reviewTextTranslated` comes back in that language, while `reviewTextOriginal` keeps what the buyer actually wrote.

#### Can I export AliExpress reviews to CSV, Excel, or JSON?

Yes. Every run's results download as JSON, CSV, or Excel from the Apify Console, or you can pull them through the API. Each review is one row, so it drops straight into a spreadsheet or your own pipeline.

#### Is it legal to scrape AliExpress?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible review pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate AliExpress Review Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use AliExpress Review Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~aliexpress-review-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls": ["https://www.aliexpress.com/item/3256811621288203.html"]}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use AliExpress Review Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call it. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/XeaaHYrAd8X1gszeD/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

AliExpress product URLs (e.g. https://www.aliexpress.com/item/1005006401040219.html) or raw numeric product IDs.

## `maxReviewsPerProduct` (type: `integer`):

Maximum reviews to scrape per product. 0 means all reviews.

## `language` (type: `string`):

Language to translate review text into. Original text is always kept too.

## `country` (type: `string`):

Review locale country code.

## `withPhotosOnly` (type: `boolean`):

Only scrape reviews that include buyer photos.

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

How many products to scrape in parallel.

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

Proxy settings. Default Apify proxy (datacenter auto-route) is recommended and cheapest.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.aliexpress.com/item/3256811621288203.html"
  ],
  "maxReviewsPerProduct": 100,
  "language": "en_US",
  "country": "US",
  "withPhotosOnly": false,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One record per review.

# 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 = {
    "productUrls": [
        "https://www.aliexpress.com/item/3256811621288203.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/aliexpress-review-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 = { "productUrls": ["https://www.aliexpress.com/item/3256811621288203.html"] }

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/aliexpress-review-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 '{
  "productUrls": [
    "https://www.aliexpress.com/item/3256811621288203.html"
  ]
}' |
apify call sourabhbgp/aliexpress-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress Review Scraper",
        "description": "Scrape every review from any AliExpress product by URL or ID: star ratings, original and translated text in 16 languages, buyer country, the variant bought, aspect tags, and buyer photos. Export to JSON, CSV, or Excel. $2.50 per 1,000 reviews.",
        "version": "0.0",
        "x-build-id": "F4vAxzYEpbKOPnntH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~aliexpress-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-aliexpress-review-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/sourabhbgp~aliexpress-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-aliexpress-review-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/sourabhbgp~aliexpress-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-aliexpress-review-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Product URLs or IDs",
                        "type": "array",
                        "description": "AliExpress product URLs (e.g. https://www.aliexpress.com/item/1005006401040219.html) or raw numeric product IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum reviews to scrape per product. 0 means all reviews.",
                        "default": 100
                    },
                    "language": {
                        "title": "Translation language",
                        "enum": [
                            "en_US",
                            "es_ES",
                            "pt_BR",
                            "ru_RU",
                            "fr_FR",
                            "de_DE",
                            "it_IT",
                            "tr_TR",
                            "pl_PL",
                            "nl_NL",
                            "ja_JP",
                            "ko_KR",
                            "ar_MA",
                            "th_TH",
                            "vi_VN",
                            "id_ID"
                        ],
                        "type": "string",
                        "description": "Language to translate review text into. Original text is always kept too.",
                        "default": "en_US"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Review locale country code.",
                        "default": "US"
                    },
                    "withPhotosOnly": {
                        "title": "Photo reviews only",
                        "type": "boolean",
                        "description": "Only scrape reviews that include buyer photos.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many products to scrape in parallel.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Default Apify proxy (datacenter auto-route) is recommended and cheapest.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
