# Alibaba Listings Scraper — Suppliers, MOQ & Price (`khadinakbar/alibaba-listings-scraper`) Actor

Search Alibaba.com B2B listings by keyword or URL: title, price range, MOQ, supplier name, country, years, verified / gold / trade-assurance flags, rating, image. Filters for price, MOQ, supplier country/years, verified-only, trade-assurance-only. PPE. MCP-ready.

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

## Pricing

from $3.00 / 1,000 alibaba 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

## Alibaba Listings Scraper

**What it does.** Search Alibaba.com B2B listings by keyword (or paste a search / category URL) and export every product card across pages — title, price range, MOQ, supplier name, country, years on Alibaba, verified / gold-supplier / trade-assurance flags, rating, image, and product URL. Lean, search-only, MCP-ready.

**When to use it.** Sourcing wholesale suppliers, building B2B price datasets, populating supplier directories, feeding sourcing-agent workflows. Use a keyword for fastest setup; paste startUrls when you've already built filtered queries.

**When NOT to use it.** Scraping a single product-detail page — this Actor is a **search/listing** scraper and rejects `/product-detail/` URLs.

---

### Output

One record per product card. Filtered-out products are **not** billed.

| Field | Type | Example |
|---|---|---|
| `productId` | string | `1600123456789` |
| `title` | string | `Bluetooth 5.3 Wireless Earbuds TWS` |
| `productUrl` | string | `https://www.alibaba.com/product-detail/..._1600123456789.html` |
| `imageUrl` | string | `https://s.alicdn.com/.../HTB1xxx.jpg` |
| `priceMin` | number | `2.50` |
| `priceMax` | number | `4.80` |
| `currency` | string | `USD` |
| `minOrderQuantity` | integer | `10` |
| `moqUnit` | string | `piece` |
| `supplierName` | string | `Shenzhen Audio Tech Co., Ltd.` |
| `supplierId` | string | `220123456789` |
| `supplierUrl` | string | `https://shenzhen-audio.en.alibaba.com` |
| `supplierCountry` | string | `CN` |
| `supplierYearsOnAlibaba` | integer | `7` |
| `isVerifiedSupplier` | boolean | `true` |
| `isGoldSupplier` | boolean | `true` |
| `isTradeAssurance` | boolean | `true` |
| `responseRatePercent` | number | `98.5` |
| `rating` | number | `4.8` |
| `reviewsCount` | integer | `342` |
| `ordersCount` | integer | `1250` |
| `position` | integer | `1` |
| `searchQuery` | string | `wireless earbuds` |
| `scrapedAt` | string (ISO 8601) | `2026-06-20T17:30:00.000Z` |

---

### Pricing — Pay Per Event

| Event | Price | When |
|---|---|---|
| Actor start | $0.00005 / GB-RAM | Once per run start |
| `product` | **$0.003** | Each product card in the dataset |

A 100-product run costs ~**$0.30 + RAM**. A 1,000-product run costs ~**$3.00 + RAM**.

Both PPE and Pay-Per-Usage are enabled — pick the billing model at run time.

---

### Inputs

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | Keyword to search (e.g. `wireless earbuds`). |
| `startUrls` | array | Alibaba search/category URLs (product-detail URLs are ignored). |
| `maxResults` | integer | Hard cap. Default 100. Doubles as your cost cap. |
| `sortBy` | enum | `relevance` (default), `transactionDesc`, `responseRate`, `priceAsc`, `priceDesc`, `newest`. |
| `minPrice` / `maxPrice` | integer | USD bounds on unit price. |
| `minMoq` | integer | Server-side MOQ floor. |
| `maxMoq` | integer | Client-side MOQ ceiling. |
| `verifiedOnly` | boolean | Keep only Verified / Gold suppliers. |
| `tradeAssuranceOnly` | boolean | Keep only Trade Assurance listings. |
| `minSupplierYears` | integer | Drop suppliers with fewer years on Alibaba. |
| `supplierCountries` | array of ISO-2 | Whitelist countries (`['CN','VN','IN','PK']`). |
| `minRating` | integer | 0–5 supplier rating floor. |
| `minOrders` | integer | Minimum transactions / orders. |
| `proxyConfiguration` | object | Defaults to Apify proxy. Residential strongly recommended. |

A null/unknown field is **dropped** when a bound is set for it (so an unknown rating never silently passes a `minRating` filter).

---

### Example calls

**Plain keyword search:**

```bash
apify call khadinakbar/alibaba-listings-scraper \
  --input='{"searchQuery":"wireless earbuds","maxResults":10}'
````

**Small-volume sourcing, verified suppliers only, China-based:**

```bash
apify call khadinakbar/alibaba-listings-scraper \
  --input='{
    "searchQuery":"yoga mat",
    "maxResults":50,
    "maxMoq":50,
    "verifiedOnly":true,
    "tradeAssuranceOnly":true,
    "supplierCountries":["CN"],
    "minSupplierYears":3,
    "sortBy":"transactionDesc"
  }'
```

**Direct search URL:**

```bash
apify call khadinakbar/alibaba-listings-scraper \
  --input='{
    "startUrls":["https://www.alibaba.com/trade/search?SearchText=led+strip&IndexArea=product_en"],
    "maxResults":100
  }'
```

***

### MCP Tool Reference

```
Tool: apify--alibaba-listings-scraper
```

**Description.** Scrape Alibaba.com B2B product listings by keyword or search/category URL. Use for sourcing, supplier discovery, B2B price datasets, sourcing-agent workflows. NOT for single product-detail pages — those URLs are ignored. Returns one record per product card with supplier (name/country/years/verified flags), price range (min/max USD), MOQ, and rating. Charged $0.003 per product.

***

### Reliability notes

- **Anti-bot.** Alibaba (Baxia family) blocks most datacenter IPs aggressively. The Actor auto-prefers Apify Residential when your account has it and gracefully falls back to Apify Datacenter US when it doesn't. Use residential for production loads.
- **Honest-fail.** If every request is blocked and zero products are collected, the run pushes a single diagnostic record explaining the block, sets a clear status message, charges $0, and exits SUCCEEDED so the Store success-rate metric stays truthful.
- **Soft-fail on bad input.** Empty input / non-Alibaba URLs / product-detail URLs → 0 products, clear status message, SUCCEEDED.
- **Cost-cap.** Triple-guard charge counter — never bills past `maxResults`.
- **Resilient extractor.** Embedded JSON (`__INITIAL_STATE__` / `runParams` / `__NUXT__`) → DOM fallback → diagnostic.

***

### Legal

Scrapes only publicly accessible search-result pages on Alibaba.com. Does not bypass authentication, does not collect personal data, and respects Apify's TOS. Users are responsible for complying with Alibaba.com's Terms of Service and applicable law in their jurisdiction. The data is provided "as is" with no warranty.

***

### Related actors

- [aliexpress-product-search-scraper](https://apify.com/khadinakbar/aliexpress-product-search-scraper) — consumer-side AliExpress search
- [aliexpress-all-in-one-scraper](https://apify.com/khadinakbar/aliexpress-all-in-one-scraper) — products + reviews + sellers
- [b2b-lead-finder-enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — Google Maps + email enrichment

Built by [khadinakbar](https://apify.com/khadinakbar).

# Actor input Schema

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

Free-text keyword to search Alibaba B2B products (e.g. 'wireless earbuds'). The Actor opens the Alibaba 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-detail page.

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

Optional list of Alibaba search or category URLs to scrape directly (e.g. https://www.alibaba.com/trade/search?SearchText=led+strip or a /catalog/ URL). Use this instead of, or together with, searchQuery. Product-detail URLs (/product-detail/...) and non-Alibaba 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 sourcing research.

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

Order in which Alibaba returns the search results. 'relevance' is Alibaba Best Match (default); 'transactionDesc' surfaces high-transaction suppliers; 'responseRate' surfaces fast-responding suppliers; '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 whose unit price (minimum of the price range) is at or above this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no minimum.

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

Only return products whose unit price (maximum of the price range) is at or below this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no maximum.

## `minMoq` (type: `integer`):

Server-side MOQ floor passed to Alibaba's search URL. Combine with maxMoq to bracket a target MOQ window. Leave empty for no MOQ lower bound.

## `maxMoq` (type: `integer`):

Drop products whose minimum order quantity (MOQ) is above this value (e.g. 100 keeps only products requiring up to 100 pieces minimum). Useful for small-volume sourcing. Applied client-side after extraction; products with unknown MOQ are dropped when this bound is set. Leave empty for no upper bound.

## `verifiedOnly` (type: `boolean`):

When enabled, keep only products from Verified or Gold Suppliers (Alibaba's supplier vetting tiers). Filtered products are not billed. Default false.

## `tradeAssuranceOnly` (type: `boolean`):

When enabled, keep only products offering Alibaba Trade Assurance (escrow + dispute protection). Filtered products are not billed. Default false.

## `minSupplierYears` (type: `integer`):

Drop products from suppliers with fewer than this many years on Alibaba (e.g. 3 keeps suppliers with 3+ years). Useful to skip brand-new sellers. Products with unknown years are dropped when this bound is set. Filtered products are not billed. Leave empty to keep all.

## `supplierCountries` (type: `array`):

Optional whitelist of supplier countries as ISO-3166 alpha-2 codes (e.g. \['CN','VN','IN','PK']). Only products whose supplier is based in one of these countries are kept. Products with unknown supplier country are dropped when this filter is set. Leave empty to allow all countries.

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

Drop products whose supplier average rating (0–5) is below this value, or whose rating is unknown. Useful to keep only well-reviewed suppliers. Filtered products are not billed. Leave empty to keep all ratings.

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

Drop products with fewer than this many recorded orders/transactions, or with unknown order count. Useful to surface proven listings. Filtered products are not billed. Leave empty to keep all.

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

Which Alibaba domain to search. Defaults to the global English site 'www.alibaba.com'.

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

Proxy settings. Residential proxies are strongly recommended — Alibaba blocks most datacenter IPs. The Actor automatically prefers Apify residential 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 for a specific proxy requirement.

## Actor input object example

```json
{
  "searchQuery": "stainless steel water bottle",
  "startUrls": [],
  "maxResults": 10,
  "sortBy": "relevance",
  "verifiedOnly": false,
  "tradeAssuranceOnly": false,
  "supplierCountries": [],
  "site": "www.alibaba.com",
  "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,
    "supplierCountries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/alibaba-listings-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,
    "supplierCountries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/alibaba-listings-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,
  "supplierCountries": []
}' |
apify call khadinakbar/alibaba-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Listings Scraper — Suppliers, MOQ & Price",
        "description": "Search Alibaba.com B2B listings by keyword or URL: title, price range, MOQ, supplier name, country, years, verified / gold / trade-assurance flags, rating, image. Filters for price, MOQ, supplier country/years, verified-only, trade-assurance-only. PPE. MCP-ready.",
        "version": "1.1",
        "x-build-id": "uvX3T6Ny5LuooaleV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~alibaba-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-alibaba-listings-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~alibaba-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-alibaba-listings-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~alibaba-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-alibaba-listings-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 Alibaba B2B products (e.g. 'wireless earbuds'). The Actor opens the Alibaba 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-detail page."
                    },
                    "startUrls": {
                        "title": "Start URLs (search/category pages)",
                        "type": "array",
                        "description": "Optional list of Alibaba search or category URLs to scrape directly (e.g. https://www.alibaba.com/trade/search?SearchText=led+strip or a /catalog/ URL). Use this instead of, or together with, searchQuery. Product-detail URLs (/product-detail/...) and non-Alibaba 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 sourcing research.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "transactionDesc",
                            "responseRate",
                            "priceAsc",
                            "priceDesc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Order in which Alibaba returns the search results. 'relevance' is Alibaba Best Match (default); 'transactionDesc' surfaces high-transaction suppliers; 'responseRate' surfaces fast-responding suppliers; '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 unit price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products whose unit price (minimum of the price range) is at or above this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum unit price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products whose unit price (maximum of the price range) is at or below this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no maximum."
                    },
                    "minMoq": {
                        "title": "Minimum MOQ to allow (lower bound)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Server-side MOQ floor passed to Alibaba's search URL. Combine with maxMoq to bracket a target MOQ window. Leave empty for no MOQ lower bound."
                    },
                    "maxMoq": {
                        "title": "Maximum MOQ to allow (upper bound)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Drop products whose minimum order quantity (MOQ) is above this value (e.g. 100 keeps only products requiring up to 100 pieces minimum). Useful for small-volume sourcing. Applied client-side after extraction; products with unknown MOQ are dropped when this bound is set. Leave empty for no upper bound."
                    },
                    "verifiedOnly": {
                        "title": "Verified / Gold Supplier only",
                        "type": "boolean",
                        "description": "When enabled, keep only products from Verified or Gold Suppliers (Alibaba's supplier vetting tiers). Filtered products are not billed. Default false.",
                        "default": false
                    },
                    "tradeAssuranceOnly": {
                        "title": "Trade Assurance only",
                        "type": "boolean",
                        "description": "When enabled, keep only products offering Alibaba Trade Assurance (escrow + dispute protection). Filtered products are not billed. Default false.",
                        "default": false
                    },
                    "minSupplierYears": {
                        "title": "Minimum supplier years on Alibaba",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop products from suppliers with fewer than this many years on Alibaba (e.g. 3 keeps suppliers with 3+ years). Useful to skip brand-new sellers. Products with unknown years are dropped when this bound is set. Filtered products are not billed. Leave empty to keep all."
                    },
                    "supplierCountries": {
                        "title": "Supplier country codes (ISO-2)",
                        "type": "array",
                        "description": "Optional whitelist of supplier countries as ISO-3166 alpha-2 codes (e.g. ['CN','VN','IN','PK']). Only products whose supplier is based in one of these countries are kept. Products with unknown supplier country are dropped when this filter is set. Leave empty to allow all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Minimum supplier rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products whose supplier average rating (0–5) is below this value, or whose rating is unknown. Useful to keep only well-reviewed suppliers. Filtered products are not billed. Leave empty to keep all ratings."
                    },
                    "minOrders": {
                        "title": "Minimum orders / transactions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop products with fewer than this many recorded orders/transactions, or with unknown order count. Useful to surface proven listings. Filtered products are not billed. Leave empty to keep all."
                    },
                    "site": {
                        "title": "Alibaba domain",
                        "enum": [
                            "www.alibaba.com"
                        ],
                        "type": "string",
                        "description": "Which Alibaba domain to search. Defaults to the global English site 'www.alibaba.com'.",
                        "default": "www.alibaba.com"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are strongly recommended — Alibaba blocks most datacenter IPs. The Actor automatically prefers Apify residential 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 for 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
