# Alibaba Scraper (`scraper-engine/alibaba-scraper`) Actor

🛍️ Alibaba Scraper extracts product details, prices, MOQ, specs, images, reviews, shipping & supplier profiles from Alibaba listings at scale. ⚙️ Ideal for product research, supplier sourcing, price tracking & lead gen. 🚀 Fast, reliable, structured data.

- **URL**: https://apify.com/scraper-engine/alibaba-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

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

### Alibaba Scraper

Alibaba Scraper is an Alibaba scraping tool that extracts structured product listings from Alibaba trade and search pages by reading embedded window.__page__data_sse*._offer_list JSON. It solves the manual copy-paste problem by providing a reliable Alibaba product scraper and Alibaba data extraction tool for marketers, developers, data analysts, and researchers. With batch inputs, live dataset updates, and a simple Alibaba scraping API workflow, it enables product research, supplier sourcing, price tracking, and catalog building at scale. 🚀

### What data / output can you get?

Below are examples of the structured fields this Alibaba data scraper returns from public listing pages. Values shown are illustrative.

| Data type | Description | Example value |
| --- | --- | --- |
| title | Product title as shown on Alibaba listing cards | “Men’s Waterproof Hiking Jacket Softshell” |
| productUrl | Canonical product page URL | “https://www.alibaba.com/product-detail/1600981574830.html” |
| price | Display price/price range string | “$12.50 - $18.90” |
| moq | Minimum order quantity (string format) | “10 pieces” |
| companyName | Supplier/company display name | “Xiamen Outdoor Gear Co., Ltd.” |
| countryCode | Supplier country code | “CN” |
| mainImage | Main image URL from the card | “https://sc01.alicdn.com/kf/HTB1.jpg” |
| productId | Numeric/ID string for the product | “1600981574830” |
| reviewScore | Average review score | “4.8” |
| reviewCount | Number of reviews | “125” |
| soldOrder | Orders/sales indicator | “480” |
| badges | Supplier/product badges list | [“Verified”, “Trade Assurance”] |

Bonus fields available in many results include: certifications, multiImage (gallery), loopSellingPoints/pcLoopSellingPoints, goldSupplierYears, supplierHref, supplierHomeHref, shippingScore, supplierServiceScore, and more. You can export results to JSON, CSV, or Excel from the Apify dataset UI.

### Key features

- ⚡️ Bold batch processing — Paste multiple Alibaba search or category URLs to scrape Alibaba products at scale in one run.
- 📈 High page limits — Control pagination with Max Pages (per URL) up to 5000 for large Alibaba product listing scraper jobs.
- 📡 Live dataset streaming — Items are pushed as soon as each page finishes, so your Alibaba data extraction tool updates in real time.
- 🧪 Browser-like requests — curl_cffi with Chrome impersonation for a reliable Alibaba web scraper without a full browser.
- 🧩 Smart proxy fallback — Optional Apify Proxy support (including residential escalation) for stability when needed.
- 🧵 Parallel page loads — Efficient concurrency with up to 8 parallel page fetches to speed up Alibaba product data extraction.
- 🧑‍💻 Developer-friendly — Connect via Apify API from your stack; great for Python Alibaba scraper workflows and automation.
- 💾 Clean exports — Export Alibaba product data to JSON, CSV, or Excel for analysis, enrichment, or catalog ingestion.

### How to use Alibaba Scraper - step by step

1. Sign in to your Apify account.
2. Open the Alibaba Scraper actor.
3. Add input URLs:
   - Paste one or more Alibaba search/category URLs.
   - Supported formats in the urls array:
     - Plain strings: "https://www.alibaba.com/trade/search?keywords=jacket&page=1"
     - Objects with url key: { "url": "https://www.alibaba.com/trade/search?keywords=jacket&page=1" }
4. Set Max Pages:
   - Choose how many result pages to open per URL (1–5000). Start small (1–3) to validate output, then scale.
5. (Optional) Configure proxy:
   - Use proxyConfiguration if you need Apify Proxy fallback. Set useApifyProxy to true to enable managed proxies.
6. Start the run:
   - Click Start. Products are streamed to the dataset as each page completes. Status messages update live.
7. Review and export:
   - Open the run’s dataset to preview rows and export to JSON, CSV, or Excel.
8. Iterate:
   - Increase Max Pages or add more URLs for larger collections.

Pro Tip: The actor also accepts the maxItems alias in input (legacy support). If provided, it behaves the same as maxPages.

### Use cases

| Use case name | Description |
| --- | --- |
| Product research for eCommerce | Identify top products, specs, and images to inform listings and merchandising based on structured Alibaba product listing scraper output. |
| Supplier sourcing & outreach | Build lists of suppliers with companyName, countryCode, and profile links for efficient lead generation and vetting. |
| Price tracking & monitoring | Monitor price ranges (price) and soldOrder to analyze market dynamics across categories and keywords. |
| Catalog building & ingestion | Export Alibaba product data to CSV/JSON for automated catalog creation in PIM/ERP or storefronts. |
| Competitor analysis | Compare badges, reviewScore, and goldSupplierYears to benchmark seller quality and positioning. |
| Data enrichment via API | Pipe dataset output into your pipelines using the Apify API for repeatable ingestion and modeling. |
| Academic & market research | Collect large, public datasets across categories for trend analysis and case studies. |
| Automation & dashboards | Schedule runs and connect dataset exports to BI tools for continuous insights. |

### Why choose Alibaba Scraper?

This Alibaba scraping service is built for precision, automation, and reliable scale.

- 🎯 Accurate listing parsing: Reads embedded window.__page__data_sse*._offer_list JSON for consistent, structured output.
- 🔁 Scales with you: Bulk URLs and up to 5000 pages per URL for high-volume runs.
- 🧑‍💻 Developer access: Ideal for Alibaba scraping API workflows and Python Alibaba scraper integrations via Apify.
- 🔒 Ethical by design: Targets publicly visible listing pages only; no login or cookies required.
- 🧰 Workflow-ready exports: Seamless JSON/CSV/Excel downloads to slot into analytics or enrichment pipelines.
- 🧱 Stable infrastructure: curl_cffi Chrome impersonation plus optional Apify Proxy (including residential fallback) for resilience.
- 🆚 Beyond extensions: More stable and scalable than ad hoc browser extensions or manual copy-paste.

Bottom line: a best Alibaba scraper choice when you need reliable Alibaba product data extraction at scale.

### Is it legal / ethical to use Alibaba Scraper?

Yes — when used responsibly. This actor collects data from publicly visible Alibaba listing pages and does not access authenticated or private content.

Guidelines for compliant use:
- Collect only public information from listing pages.
- Respect Alibaba’s terms of service and applicable laws (e.g., GDPR/CCPA where relevant).
- Avoid scraping personal or sensitive data.
- Use results responsibly for analysis and sourcing, not spam.
- Consult your legal team for edge cases and jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "urls": [
    "https://www.alibaba.com/trade/search?keywords=men%27s%20jackets&page=1",
    { "url": "https://www.alibaba.com/trade/search?keywords=hiking%20backpack&page=1" }
  ],
  "maxPages": 2,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

Input parameters

- urls (array, required)
  - Description: Add every Alibaba page you want to collect from — one URL per line. Works best with search results and category browse pages. Supports plain strings or objects with a url key.
  - Default: none
- maxPages (integer, optional)
  - Description: How many result pages to open per URL. Dataset updates live as each page finishes. Try 1–3 first, then increase.
  - Minimum: 1, Maximum: 5000, Default: 1
  - Note: The actor also accepts maxItems as an alias for this setting.
- proxyConfiguration (object, optional)
  - Description: Optional — configure Apify’s managed proxies for stable access in challenging network conditions. Set useApifyProxy to true to enable fallback.
  - Default: { "useApifyProxy": false }

Example JSON output

```json
{
  "badges": ["Verified", "Trade Assurance"],
  "certifications": ["CE", "ISO9001"],
  "chatToken": "",
  "companyId": "1234567890",
  "companyLogo": "https://sc01.alicdn.com/kf/logo.png",
  "companyName": "Xiamen Outdoor Gear Co., Ltd.",
  "contactSupplier": "https://www.alibaba.com/contact/supplier/abc",
  "countryCode": "CN",
  "customGroup": "",
  "displayStarLevel": "5",
  "eurl": "",
  "goldSupplierYears": "7",
  "id": "offer_1600981574830",
  "isShowAd": false,
  "loopSellingPoints": ["Waterproof fabric", "Breathable lining"],
  "lyb": false,
  "mainImage": "https://sc01.alicdn.com/kf/HTB1.jpg",
  "moq": "10 pieces",
  "moqV2": "10",
  "multiImage": [
    "https://sc01.alicdn.com/kf/HTB1_1.jpg",
    "https://sc01.alicdn.com/kf/HTB1_2.jpg"
  ],
  "pcLoopSellingPoints": ["Fast shipping", "OEM available"],
  "price": "$12.50 - $18.90",
  "productId": "1600981574830",
  "productScore": "98",
  "productUrl": "https://www.alibaba.com/product-detail/1600981574830.html",
  "reviewCount": "125",
  "reviewScore": "4.8",
  "shippingScore": "4.7",
  "showAddToCart": false,
  "showCrown": false,
  "soldOrder": "480",
  "supplierHomeHref": "https://abc.en.alibaba.com",
  "supplierHref": "https://www.alibaba.com/company_profile/abc.html",
  "supplierService": "On-time delivery",
  "supplierServiceScore": "4.6",
  "title": "Men’s Waterproof Hiking Jacket Softshell",
  "tmlid": "",
  "trackInfo": ""
}
```

Notes

- Output items contain only the fields above. Some fields may be empty strings, false, or empty arrays if not available on a given listing.
- Results stream to the dataset as pages complete. Export via the Apify UI in JSON, CSV, or Excel.

### FAQ

#### Do I need to log in or use cookies to scrape Alibaba with this tool?

No. The actor fetches publicly visible listing pages using browser-like HTTP (curl\_cffi with Chrome impersonation). It does not require login or cookies.

#### Can I scrape multiple Alibaba URLs in one run?

Yes. You can paste a list of search or category URLs, and the actor will process each in order. It supports both string URLs and objects like { "url": "..." } in the urls array.

#### How many products can I collect per URL?

You control pagination via Max Pages (per URL), up to 5000. Start small (1–3) to validate results, then scale. The actor also accepts maxItems as a legacy alias for this setting.

#### Does it support proxies or residential IPs?

Yes. If you enable proxyConfiguration with useApifyProxy set to true, the actor will use Apify’s managed proxies and can escalate to residential when needed for stability.

#### How do I export the data?

All items stream to the Apify dataset. You can export to JSON, CSV, or Excel directly from the dataset UI or retrieve data via the Apify API for automation.

#### Is there an API or Python workflow I can use?

Yes. Runs and datasets are accessible via the Apify API, making it easy to integrate into Python Alibaba scraper workflows or other data pipelines.

#### Is this an Alibaba scraper Chrome extension?

No. This is an Apify actor (server-side) rather than a browser extension. It’s more reliable and scalable than extension-based approaches for Alibaba product data extraction.

#### What kinds of data does it extract from Alibaba?

It returns listing-level fields such as title, productUrl, price, moq, companyName, countryCode, images, reviews, badges, and supplier links, plus additional metadata like certifications and service scores when present.

### Closing CTA / Final thoughts

Alibaba Scraper is built for fast, reliable Alibaba product data extraction at scale. It delivers structured product, supplier, and pricing details from public listing pages with live dataset streaming and robust networking.

Whether you’re a marketer, developer, analyst, or researcher, you’ll get clean exports for price tracking, supplier sourcing, catalog building, and analytics. Developers can orchestrate runs and pull results via the Apify API for Python or other automation stacks.

Start extracting smarter with a scalable Alibaba scraping tool that turns public listings into actionable, structured data.

# Actor input Schema

## `urls` (type: `array`):

**Add every Alibaba page you want to collect from** — one URL per line. 📝

✅ **Works well:** search results, category browse pages, and similar listing views you open in a normal browser.

🧭 **Tip:** Copy the address bar from Chrome or Edge after you’ve set filters (keywords, category, etc.) — those settings travel with the link.

📦 **Bulk:** Paste many URLs at once; each is processed in order.

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

How many **result pages** to open **per URL** in your list (each page lists many products). 📚

📊 **Dataset updates live** — rows appear in the output table as each page finishes.

🎯 Try **1–3** first, then raise when you’re happy.

⏱️ Higher values mean more requests and longer runs.

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

**Optional** — leave off for a simple start. 🔓

When enabled here, Apify’s managed proxies can help with **stable access** in challenging network conditions. Settings apply through the standard Apify proxy picker below.

🙈 **Privacy:** Your search URLs and results stay in your Apify run; configure proxies only if your workflow needs them.

💬 **Not sure?** Keep defaults and only change this if a run fails or your team asks for proxy usage.

## Actor input object example

```json
{
  "urls": [
    "https://www.alibaba.com/trade/search?fsb=y&IndexArea=product_en&categoryId=127734135&has4Tab=true&keywords=Men%27s+Jackets&originKeywords=Men%27s+Jackets&productId=1600981574830&tab=all&&page=1&spm=undefined.pagination.0"
  ],
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.alibaba.com/trade/search?fsb=y&IndexArea=product_en&categoryId=127734135&has4Tab=true&keywords=Men%27s+Jackets&originKeywords=Men%27s+Jackets&productId=1600981574830&tab=all&&page=1&spm=undefined.pagination.0"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/alibaba-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 = {
    "urls": ["https://www.alibaba.com/trade/search?fsb=y&IndexArea=product_en&categoryId=127734135&has4Tab=true&keywords=Men%27s+Jackets&originKeywords=Men%27s+Jackets&productId=1600981574830&tab=all&&page=1&spm=undefined.pagination.0"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/alibaba-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 '{
  "urls": [
    "https://www.alibaba.com/trade/search?fsb=y&IndexArea=product_en&categoryId=127734135&has4Tab=true&keywords=Men%27s+Jackets&originKeywords=Men%27s+Jackets&productId=1600981574830&tab=all&&page=1&spm=undefined.pagination.0"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/alibaba-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Scraper",
        "description": "🛍️ Alibaba Scraper extracts product details, prices, MOQ, specs, images, reviews, shipping & supplier profiles from Alibaba listings at scale. ⚙️ Ideal for product research, supplier sourcing, price tracking & lead gen. 🚀 Fast, reliable, structured data.",
        "version": "0.1",
        "x-build-id": "qPJqSwf6WKoI2Ov5T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~alibaba-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-alibaba-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/scraper-engine~alibaba-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-alibaba-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/scraper-engine~alibaba-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-alibaba-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Page URLs (bulk)",
                        "type": "array",
                        "description": "**Add every Alibaba page you want to collect from** — one URL per line. 📝\n\n✅ **Works well:** search results, category browse pages, and similar listing views you open in a normal browser.\n\n🧭 **Tip:** Copy the address bar from Chrome or Edge after you’ve set filters (keywords, category, etc.) — those settings travel with the link.\n\n📦 **Bulk:** Paste many URLs at once; each is processed in order.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "🔢 Max Pages",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many **result pages** to open **per URL** in your list (each page lists many products). 📚\n\n📊 **Dataset updates live** — rows appear in the output table as each page finishes.\n\n🎯 Try **1–3** first, then raise when you’re happy.\n\n⏱️ Higher values mean more requests and longer runs.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration",
                        "type": "object",
                        "description": "**Optional** — leave off for a simple start. 🔓\n\nWhen enabled here, Apify’s managed proxies can help with **stable access** in challenging network conditions. Settings apply through the standard Apify proxy picker below.\n\n🙈 **Privacy:** Your search URLs and results stay in your Apify run; configure proxies only if your workflow needs them.\n\n💬 **Not sure?** Keep defaults and only change this if a run fails or your team asks for proxy usage."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
