# AliExpress Product Search Scraper (`khadinakbar/aliexpress-product-search-scraper`) Actor

Search AliExpress by keyword (or paste a search/category URL) and export product listing cards: title, price, original price, discount, rating, orders sold, store, image, and product URL. Filter by sort order, price range, free shipping, minimum rating, and minimum orders. Pay-per-event. MCP-ready.

- **URL**: https://apify.com/khadinakbar/aliexpress-product-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 aliexpress product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Product Search Scraper

Search AliExpress by keyword (or paste a search/category URL) and export every product listing card as clean, structured JSON — **price, original price, discount, rating, orders sold, store, image, and product URL** — with built-in filters for sort order, price range, free shipping, minimum rating, and minimum orders. Built for product researchers, dropshippers, and AI agents. **MCP-ready.**

### What you get

One record per product found in AliExpress search results:

| Field | Description |
|---|---|
| `position` | Rank of the product across the result pages (1, 2, 3, …) |
| `title` | Product title |
| `price` | Current sale price (number) |
| `originalPrice` | Pre-discount price, when shown |
| `discountPercent` | Computed discount % (sale vs original) |
| `currency` | Currency code AliExpress served (e.g. `USD`, `EUR`) |
| `rating` | Average star rating, 0–5 |
| `reviewsCount` | Number of reviews |
| `ordersCount` | Orders / units sold |
| `storeName` / `storeId` / `storeUrl` | Seller store (when present on the card) |
| `imageUrl` | Main product image |
| `productUrl` | Canonical product page URL |
| `searchQuery` | The keyword that produced this result |
| `productId` | AliExpress product id |
| `site` | The AliExpress domain searched |
| `scrapedAt` | ISO-8601 timestamp |

### When to use this Actor

- **Use it** to turn an AliExpress keyword (or category page) into a structured product list — for product research, price/discount monitoring, best-seller discovery, niche scouting, and feeding AI agents.
- **Use it** when you want filtering at the source: sort by best-selling or price, restrict to a price band, free shipping, a minimum rating, or a minimum number of orders.
- **Don't use it** to scrape a single product's full detail page (specs, SKU variants, full gallery, description) or its reviews — that's the job of the **AliExpress All-in-One Scraper** (`khadinakbar/aliexpress-all-in-one-scraper`), which accepts product URLs and `includeReviews`.

### Pricing — Pay-per-event

| Event | Price | When it fires |
|---|---|---|
| Actor start | $0.00005 | Once per run (per GB RAM) |
| AliExpress product scraped | **$0.002** | Per product returned in the dataset |

Products dropped by your filters (`minRating`, `minOrders`, `minPrice`, `maxPrice`) are **not** charged. `maxResults` is a hard cost ceiling — set it and you know the maximum spend before the run starts (the Actor also logs the cap up front). A typical 100-product run costs about **$0.20**.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchQuery` | string | `wireless earbuds` (prefill) | Keyword to search |
| `startUrls` | array | `[]` | AliExpress **search/category** URLs (product URLs ignored) |
| `maxResults` | integer | `100` | Cap on products + cost ceiling |
| `sortBy` | enum | `relevance` | `relevance`, `ordersDesc`, `priceAsc`, `priceDesc`, `newest` |
| `minPrice` / `maxPrice` | integer | — | Price band, in the site's currency |
| `freeShipping` | boolean | `false` | Free shipping to the ship-to country only |
| `minRating` | integer | — | Keep products at this star rating (0–5) or higher |
| `minOrders` | integer | — | Keep products with at least this many orders |
| `site` | enum | `aliexpress.com` | Regional domain (US, DE, FR, ES, IT, PT, RU) |
| `shipCountry` | string | `US` | Ship-to country + proxy country |
| `proxyConfiguration` | object | residential | Defaults to Apify residential; falls back to datacenter US |

#### Example input

```json
{
  "searchQuery": "mechanical keyboard",
  "maxResults": 50,
  "sortBy": "ordersDesc",
  "minPrice": 20,
  "maxPrice": 80,
  "minRating": 4,
  "minOrders": 100,
  "freeShipping": true,
  "site": "aliexpress.com",
  "shipCountry": "US"
}
````

#### Example output record

```json
{
  "recordType": "product",
  "position": 1,
  "productId": "1005006789012345",
  "title": "Mechanical Keyboard 87 Keys Hot-Swappable RGB",
  "price": 34.99,
  "originalPrice": 69.99,
  "discountPercent": 50,
  "currency": "USD",
  "rating": 4.8,
  "reviewsCount": 1203,
  "ordersCount": 5400,
  "storeName": "Keyboard Official Store",
  "storeId": "1101234567",
  "storeUrl": "https://www.aliexpress.com/store/1101234567",
  "imageUrl": "https://ae01.alicdn.com/kf/Sxxxxxxxx.jpg",
  "productUrl": "https://www.aliexpress.com/item/1005006789012345.html",
  "searchQuery": "mechanical keyboard",
  "site": "aliexpress.com",
  "scrapedAt": "2026-06-19T08:00:00.000Z"
}
```

### How it works

The Actor opens the AliExpress search results page (`/w/wholesale-<keyword>.html`) with your sort and filter parameters, then reads the products from the page's embedded SSR JSON (the same data AliExpress uses to render the grid), falling back to DOM parsing if the JSON shape shifts. It auto-paginates through result pages until `maxResults` is reached. Rating, orders, and price filters are re-checked on the parsed values so a filtered result is never billed.

It uses a real Chromium browser with rotating fingerprints and a session pool, and prefers residential proxies (strongly recommended — AliExpress blocks datacenter IPs). If residential isn't available on your account, it gracefully falls back to Apify datacenter (US).

### Use with AI agents (MCP)

This Actor is MCP-ready. Connect it through the [Apify MCP server](https://mcp.apify.com) and an agent can call it with a single keyword and get back a structured product list to reason over — ideal for shopping assistants, price comparison, and product-research agents. Input descriptions and the flat output schema are written for LLM consumption.

### Tips

- For best-selling products, set `sortBy: "ordersDesc"` and `minOrders` to filter out untested listings.
- For regional pricing, set both `site` and `shipCountry` to the same market.
- To bulk-scrape several searches, run the Actor multiple times (one keyword each) or pass several search/category URLs in `startUrls`.

### Reliability

- **Soft-fail on bad input** — missing keyword/URLs ends the run with a clear message, not a crash.
- **Honest-fail on anti-bot exhaustion** — if every request is blocked and nothing is collected, the run reports the block instead of silently succeeding empty.
- **Cost-cap visibility** — the maximum spend is logged before any charge fires, and a triple-guard counter never charges past your `maxResults`.
- **Graceful degradation** — partial pages still produce results; per-field gaps are flagged in `_warnings`, never thrown.

### Limitations

- This Actor scrapes **search/category result cards only**. For a single product's full specs, SKU variants, gallery, description, and reviews, use the **AliExpress All-in-One Scraper**.
- `storeName` / `storeId` may be `null` on some search cards — AliExpress omits store data from certain result layouts (it's present on the product page). This is an upstream limitation, not a bug.
- `currency` reflects what AliExpress actually served; with residential proxies the IP geo can occasionally differ from the requested `shipCountry`.

### Legal

This Actor collects only publicly available AliExpress search-results data. You are responsible for using the data in compliance with AliExpress's Terms of Service, applicable laws, and data-protection regulations (including the GDPR where relevant). Do not use it to collect personal data without a lawful basis. This Actor is provided for legitimate market-research, price-monitoring, and product-discovery use cases.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword to search AliExpress products (e.g. 'wireless earbuds'). The Actor opens the AliExpress search results page and collects every product listing card across pages. Leave empty if you instead provide startUrls. NOT a single product URL — this Actor searches and returns many products, it does not scrape one product page.

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

Optional list of AliExpress search or category URLs to scrape directly (e.g. https://www.aliexpress.com/w/wholesale-led-strip.html or a /category/ URL). Use this instead of, or together with, searchQuery. Product URLs (/item/...) and non-AliExpress URLs are ignored — this Actor only scrapes search/category result pages.

## `maxResults` (type: `integer`):

Maximum number of product records to return. The Actor auto-paginates until this cap is reached, then stops, so it doubles as your cost ceiling (each product is one billable event). Defaults to 100. Set higher for bulk research.

## `sortBy` (type: `string`):

Order in which AliExpress returns the search results. 'relevance' is AliExpress Best Match (default); 'ordersDesc' is best-selling first; 'priceAsc'/'priceDesc' sort by price; 'newest' shows recently listed items. Applies to keyword searches; for startUrls the URL's own sort is respected.

## `minPrice` (type: `integer`):

Only return products at or above this price, in the site's currency (e.g. 5 means $5+ on aliexpress.com). Applied both as an AliExpress URL filter and a safety re-check on the parsed price. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Only return products at or below this price, in the site's currency (e.g. 50 means up to $50 on aliexpress.com). Applied both as an AliExpress URL filter and a safety re-check on the parsed price. Leave empty for no maximum.

## `freeShipping` (type: `boolean`):

When enabled, restricts the AliExpress search to products offering free shipping to the ship-to country. Default false.

## `minRating` (type: `integer`):

Drop products whose average star rating (0–5) is below this value, or whose rating is unknown. Useful to keep only well-reviewed products (e.g. 4 keeps 4★ and up). Filtered products are not billed. Leave empty to keep all ratings.

## `minOrders` (type: `integer`):

Drop products with fewer than this many orders/sold, or whose orders count is unknown. Useful to surface proven sellers (e.g. 100 keeps items with 100+ sold). Filtered products are not billed. Leave empty to keep all.

## `site` (type: `string`):

Which AliExpress regional domain to search. Affects language and default currency of returned data. Use 'aliexpress.com' (global English) unless you need region-specific pricing. Default 'aliexpress.com'.

## `shipCountry` (type: `string`):

Two-letter ISO country code used as the ship-to country and the residential proxy country (e.g. 'US', 'GB', 'DE'). Affects shipping options and which prices AliExpress shows. Defaults to 'US'.

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

Proxy settings. Residential proxies are strongly recommended — AliExpress blocks datacenter IPs. The Actor automatically prefers Apify residential (pinned to the ship-to country) when your account has it, and gracefully falls back to Apify datacenter when it does not — so leaving this at the default works on any plan. Override only if you have a specific proxy requirement.

## Actor input object example

```json
{
  "searchQuery": "mechanical keyboard",
  "startUrls": [],
  "maxResults": 10,
  "sortBy": "relevance",
  "freeShipping": false,
  "site": "aliexpress.com",
  "shipCountry": "GB",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All product listing records found across the search/category pages. Download as JSON, CSV, Excel, HTML, or RSS.

# 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 = {
    "searchQuery": "wireless earbuds",
    "startUrls": [],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/aliexpress-product-search-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 = {
    "searchQuery": "wireless earbuds",
    "startUrls": [],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/aliexpress-product-search-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 '{
  "searchQuery": "wireless earbuds",
  "startUrls": [],
  "maxResults": 10
}' |
apify call khadinakbar/aliexpress-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress Product Search Scraper",
        "description": "Search AliExpress by keyword (or paste a search/category URL) and export product listing cards: title, price, original price, discount, rating, orders sold, store, image, and product URL. Filter by sort order, price range, free shipping, minimum rating, and minimum orders. Pay-per-event. MCP-ready.",
        "version": "1.0",
        "x-build-id": "ahOK0Oyq4UDItvxaN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~aliexpress-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-aliexpress-product-search-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/khadinakbar~aliexpress-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-aliexpress-product-search-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/khadinakbar~aliexpress-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-aliexpress-product-search-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": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword to search AliExpress products (e.g. 'wireless earbuds'). The Actor opens the AliExpress search results page and collects every product listing card across pages. Leave empty if you instead provide startUrls. NOT a single product URL — this Actor searches and returns many products, it does not scrape one product page."
                    },
                    "startUrls": {
                        "title": "Start URLs (search/category pages)",
                        "type": "array",
                        "description": "Optional list of AliExpress search or category URLs to scrape directly (e.g. https://www.aliexpress.com/w/wholesale-led-strip.html or a /category/ URL). Use this instead of, or together with, searchQuery. Product URLs (/item/...) and non-AliExpress URLs are ignored — this Actor only scrapes search/category result pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product records to return. The Actor auto-paginates until this cap is reached, then stops, so it doubles as your cost ceiling (each product is one billable event). Defaults to 100. Set higher for bulk research.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "ordersDesc",
                            "priceAsc",
                            "priceDesc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Order in which AliExpress returns the search results. 'relevance' is AliExpress Best Match (default); 'ordersDesc' is best-selling first; 'priceAsc'/'priceDesc' sort by price; 'newest' shows recently listed items. Applies to keyword searches; for startUrls the URL's own sort is respected.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products at or above this price, in the site's currency (e.g. 5 means $5+ on aliexpress.com). Applied both as an AliExpress URL filter and a safety re-check on the parsed price. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products at or below this price, in the site's currency (e.g. 50 means up to $50 on aliexpress.com). Applied both as an AliExpress URL filter and a safety re-check on the parsed price. Leave empty for no maximum."
                    },
                    "freeShipping": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "When enabled, restricts the AliExpress search to products offering free shipping to the ship-to country. Default false.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products whose average star rating (0–5) is below this value, or whose rating is unknown. Useful to keep only well-reviewed products (e.g. 4 keeps 4★ and up). Filtered products are not billed. Leave empty to keep all ratings."
                    },
                    "minOrders": {
                        "title": "Minimum orders sold",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop products with fewer than this many orders/sold, or whose orders count is unknown. Useful to surface proven sellers (e.g. 100 keeps items with 100+ sold). Filtered products are not billed. Leave empty to keep all."
                    },
                    "site": {
                        "title": "AliExpress domain",
                        "enum": [
                            "aliexpress.com",
                            "aliexpress.us",
                            "de.aliexpress.com",
                            "fr.aliexpress.com",
                            "es.aliexpress.com",
                            "it.aliexpress.com",
                            "pt.aliexpress.com",
                            "ru.aliexpress.com"
                        ],
                        "type": "string",
                        "description": "Which AliExpress regional domain to search. Affects language and default currency of returned data. Use 'aliexpress.com' (global English) unless you need region-specific pricing. Default 'aliexpress.com'.",
                        "default": "aliexpress.com"
                    },
                    "shipCountry": {
                        "title": "Ship-to country",
                        "type": "string",
                        "description": "Two-letter ISO country code used as the ship-to country and the residential proxy country (e.g. 'US', 'GB', 'DE'). Affects shipping options and which prices AliExpress shows. Defaults to 'US'.",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are strongly recommended — AliExpress blocks datacenter IPs. The Actor automatically prefers Apify residential (pinned to the ship-to country) when your account has it, and gracefully falls back to Apify datacenter when it does not — so leaving this at the default works on any plan. Override only if you have a specific proxy requirement.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
