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

🛒 Alibaba Scraper (alibaba-scraper) extracts public product & supplier data—titles, prices, MOQs, specs, ratings, reviews & images—from Alibaba listings at scale. 🚀 Ideal for sourcing, market research, price monitoring & e‑commerce analytics. Exports CSV/JSON.

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

## Pricing

from $5.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 Apify actor that extracts public product and supplier details from Alibaba search and category listings at scale. It solves the pain of manual copy-paste by turning product titles, prices, MOQs, ratings, images, and supplier info into structured data you can analyze and export. Built for marketers, developers, data analysts, and researchers, this Alibaba data extractor helps you power sourcing, market research, price monitoring, and e‑commerce analytics workflows at scale. 🚀

### What data / output can you get?

This Alibaba product scraper reads embedded page JSON and pushes structured product records to the Apify dataset. Below are common fields (as they appear in the output):

| Data type | Description | Example value |
| --- | --- | --- |
| title | Product title text | “Men’s Winter Down Jacket Waterproof Outdoor” |
| productUrl | Direct product link | https://www.alibaba.com/product-detail/1601234567890.html |
| price | Displayed price or range | “US $12.00 – $15.00” |
| moq | Minimum order quantity (if shown) | “100 pieces” |
| companyName | Supplier/company name | “Hangzhou XYZ Garments Co., Ltd.” |
| countryCode | Supplier country code | “CN” |
| mainImage | Primary product image URL | https://sc04.alicdn.com/kf/abc123.jpg |
| multiImage | Gallery image URLs | ["https://.../1.jpg","https://.../2.jpg"] |
| reviewScore | Aggregate rating score | "4.6" |
| reviewCount | Number of reviews | "128" |
| soldOrder | Orders or sales indicator | "560" |
| badges | Seller or listing badges | ["verified","trade_assurance"] |

Bonus fields captured when available include: certifications, goldSupplierYears, displayStarLevel, supplierHref, supplierHomeHref, supplierService, supplierServiceScore, shippingScore, chatToken, trackInfo, and more. You can export your dataset to JSON, CSV, or Excel directly from Apify.

### Key features

- ⚡️ Live dataset streaming  
  Products are pushed to the dataset as soon as each page finishes — perfect for monitoring progress and iterative QA.

- 📦 Batch scraping at scale  
  Paste many Alibaba URLs and set Max Pages per URL (up to 5,000). Ideal for large catalog builds with this Alibaba web scraping tool.

- 🕵️ Browser-like HTTP requests  
  Uses curl_cffi with Chrome impersonation for high-fidelity requests that emulate real browsers.

- 🌐 Optional Apify Proxy fallback  
  Enable proxyConfiguration to let the actor escalate through Apify Proxy (including RESIDENTIAL when needed) for stable access.

- 🧰 Developer-friendly & automation-ready  
  Built as an Apify actor — integrate via the Apify API, orchestrate in workflows, or connect to scripts as your Alibaba scraping API.

- 💾 Flexible exports  
  Export structured results to JSON, CSV, or Excel for downstream analysis, enrichment, or BI dashboards.

- 🛡️ Production-oriented reliability  
  Internal checks detect blocked/invalid responses and retry with proxy escalation, helping this Alibaba scraper tool run consistently.

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

1. Create or log in to your Apify account.  
2. Open the Alibaba Scraper actor in the Apify Console.  
3. Add input data: paste one or more Alibaba search or category URLs into “Page URLs (bulk)”. You can provide:  
   - 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” to control how many result pages to load per URL. Start low (1–3) to preview results, then scale up (up to 5,000).
5. (Optional) Configure “Proxy configuration” if you need added stability. Enabling useApifyProxy allows managed proxy fallback and residential escalation as needed.
6. Click Start. Watch logs and the dataset — items appear live as pages complete.
7. Download your results from the Dataset tab in JSON, CSV, or Excel, or access them programmatically via the Apify API.

Pro Tip: For backward compatibility, the actor also accepts the legacy “maxItems” input key as an alias for “Max Pages”.

### Use cases

| Use case name | Description |
| --- | --- |
| Supplier sourcing & vetting | Aggregate titles, MOQs, ratings, and badges to shortlist reliable suppliers faster with an Alibaba supplier scraper workflow. |
| Market & category research | Map product attributes and pricing ranges across categories for trend analysis with an Alibaba catalog scraper. |
| Price monitoring | Track displayed price ranges and orders over time for competitive intelligence using an Alibaba price scraper. |
| Product catalog building | Rapidly assemble product listings (titles, images, specs hints) for e‑commerce operations with an Alibaba product listing scraper. |
| Data enrichment pipelines | Feed structured output into CRMs or BI tools via the Apify API for automated enrichment. |
| Academic & policy research | Collect public product and supplier metadata for studies on trade patterns or market structures. |
| Developer integrations | Use the Apify API to pull dataset results into Python scripts or ETL tools for custom Alibaba scraping Python script pipelines. |

### Why choose Alibaba Scraper?

This Alibaba product data scraper is built for precision, scale, and reliability on the Apify platform.

- ✅ Accurate, structured extraction from public listing pages
- 🌍 Works globally with optional Apify Proxy and residential escalation
- 📈 Scales from quick tests to thousands of pages per run
- 🔗 Developer access via Apify API for automation and integration
- 🛡️ Ethical by design — targets public data only, no login or cookies needed
- 💰 Cost-effective vs. brittle browser extensions and manual workflows
- 🧩 Connects easily to your data toolchain through standard exports

Compared with lightweight browser extensions or unstable bots, this production-grade Alibaba scraping bot focuses on consistency and data quality — ideal for operations teams and developers alike.

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

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

Guidelines for compliant use:
- Only collect data that is publicly available on listing pages.
- Respect Alibaba’s terms and applicable laws and regulations (e.g., GDPR, CCPA).
- Avoid scraping personal or sensitive data.
- Use results for legitimate purposes (research, analytics, sourcing) and consult your legal team for edge cases.

### Input parameters & output format

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

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 opened in a normal browser.\
  Default: not set

- maxPages (integer, optional)\
  Description: How many result pages to open per URL. Dataset updates live as each page finishes. Minimum 1, maximum 5000.\
  Default: 1

- proxyConfiguration (object, optional)\
  Description: Optional — configure Apify Proxy for stable access in challenging network conditions.\
  Default: not set (UI prefill: { "useApifyProxy": false })

Note: The actor also accepts the legacy “maxItems” input key as an alias for pages per URL.

#### Example JSON output

Each product is pushed to the dataset as a single JSON object with the following keys (some may be empty if not present on the page):

```json
{
  "badges": ["verified", "trade_assurance"],
  "certifications": ["CE", "ISO9001"],
  "chatToken": "",
  "companyId": "1234567890",
  "companyLogo": "https://sc04.alicdn.com/kf/logo123.png",
  "companyName": "Hangzhou XYZ Garments Co., Ltd.",
  "contactSupplier": "",
  "countryCode": "CN",
  "customGroup": "",
  "displayStarLevel": "5",
  "eurl": "",
  "goldSupplierYears": "6",
  "id": "offer_1601234567890",
  "isShowAd": false,
  "loopSellingPoints": ["Waterproof", "Lightweight", "Warm filling"],
  "lyb": false,
  "mainImage": "https://sc04.alicdn.com/kf/abc123.jpg",
  "moq": "100 pieces",
  "moqV2": "100",
  "multiImage": [
    "https://sc04.alicdn.com/kf/abc123_1.jpg",
    "https://sc04.alicdn.com/kf/abc123_2.jpg"
  ],
  "pcLoopSellingPoints": ["Fast dispatch", "Customizable"],
  "price": "US $12.00 - $15.00",
  "productId": "1601234567890",
  "productScore": "98",
  "productUrl": "https://www.alibaba.com/product-detail/1601234567890.html",
  "reviewCount": "128",
  "reviewScore": "4.6",
  "shippingScore": "4.8",
  "showAddToCart": false,
  "showCrown": false,
  "soldOrder": "560",
  "supplierHomeHref": "https://xyzgarments.en.alibaba.com/",
  "supplierHref": "https://www.alibaba.com/supplier/xyzgarments",
  "supplierService": "On-time delivery",
  "supplierServiceScore": "4.7",
  "title": "Men’s Winter Down Jacket Waterproof Outdoor",
  "tmlid": "",
  "trackInfo": ""
}
```

Output notes:

- Missing data are filled with safe defaults (empty strings, false, or empty arrays).
- The default dataset view highlights: title, productUrl, price, companyName, countryCode, mainImage, productId, reviewScore, soldOrder.
- Export in JSON, CSV, or Excel from the Apify dataset.

### FAQ

#### Do I need to log in or provide cookies to use this Alibaba product scraper?

No. The actor targets publicly visible Alibaba search and category pages and does not require login or cookies.

#### Can I run bulk URLs with this Alibaba data scraper?

Yes. You can paste many URLs into the “Page URLs (bulk)” field. The actor will fetch up to your specified Max Pages per URL and push items live to the dataset.

#### How many pages can I scrape per URL?

You can set Max Pages from 1 up to 5000 per URL. Start with a small value (1–3) to validate output, then scale up as needed.

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

Yes. If you enable proxyConfiguration with useApifyProxy, the actor can fall back to Apify Proxy and escalate to RESIDENTIAL when needed for stability.

#### What fields does the Alibaba product data scraper return?

The actor pushes structured product records including title, productUrl, price, moq, companyName, countryCode, mainImage, reviewScore, reviewCount, soldOrder, badges, and additional metadata like certifications, goldSupplierYears, and supplier links. Some fields may be empty if not present on the page.

#### Can I integrate results via API or a Python script?

Yes. Access your dataset programmatically using the Apify API to build an Alibaba scraping Python script or connect to ETL pipelines. You can also download CSV/JSON/Excel directly.

#### Is using this Alibaba scraper tool legal?

Yes, when used responsibly to collect public data. You’re responsible for complying with Alibaba’s terms and applicable laws (e.g., GDPR, CCPA). The actor does not access private or authenticated content.

#### What’s the difference between maxPages and maxItems?

In addition to maxPages, the actor accepts a legacy key maxItems as an alias for “pages per URL.” Either will work; maxPages is the primary input field in the UI.

### Closing CTA / Final thoughts

Alibaba Scraper is built to turn Alibaba product listings into clean, structured datasets for sourcing, research, and analytics. With bulk URL support, live dataset streaming, optional proxy fallback, and flexible exports, it’s ideal for marketers, developers, analysts, and researchers. Integrate via the Apify API to automate end-to-end pipelines, or export CSV/JSON/Excel for quick analysis. Start extracting smarter product and supplier insights at scale with this reliable Alibaba product scraper today.

# 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("scrapier/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("scrapier/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 scrapier/alibaba-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Scraper",
        "description": "🛒 Alibaba Scraper (alibaba-scraper) extracts public product & supplier data—titles, prices, MOQs, specs, ratings, reviews & images—from Alibaba listings at scale. 🚀 Ideal for sourcing, market research, price monitoring & e‑commerce analytics. Exports CSV/JSON.",
        "version": "0.1",
        "x-build-id": "TITeYYwzVf1dA8brJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~alibaba-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-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/scrapier~alibaba-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-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/scrapier~alibaba-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
