# Alibaba.com Scraper API - B2B Products, Prices, MOQ & Suppliers (`dami_studio/alibaba-com-scraper`) Actor

Scrape Alibaba.com search results: product title, price range, minimum order quantity and unit, supplier company, country, years on Alibaba, rating, review count, units sold, certifications, images and product URL. Prices convert to your chosen currency. No login, no API key.

- **URL**: https://apify.com/dami\_studio/alibaba-com-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 product returneds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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.com Scraper API

Search Alibaba.com — the English-language B2B export marketplace — and get structured product rows
back: title, price range, minimum order quantity and unit, the supplier company, its country, years
on Alibaba, rating, review count, units sold, certifications, images and the product URL.

No Alibaba account, no cookies, no captcha solving, no proxy of your own. Type a search term, get rows.

### Price

**$0.85 per 1,000 products**, plus $0.001 to start a run.

A flat rate — no volume tiers to unlock and no plan gates, the same number on your first run as on
your thousandth. You are charged per product row returned — a run that finds nothing costs only the
start fee, and sample rows, diagnostic rows and duplicates are never charged.

| Products | Cost |
|---|---|
| 500 | $0.43 |
| 2,000 | $1.70 |
| 10,000 | $8.50 |
| 100,000 | $85.00 |

### What a row looks like

A real row from a run on `led light`:

```json
{
  "productId": "1601048127519",
  "title": "Neon Lights 12V LED Light Strip Single Color LED Neon Silicone LED Strip Light Outdoor Waterproof Neon LED Strip",
  "productUrl": "https://www.alibaba.com/product-detail/Neon-Lights-12V-LED-Light-Strip_1601048127519.html",
  "priceMin": 0.35,
  "priceMax": 0.35,
  "priceText": "$0.35",
  "currency": "USD",
  "promotionPrice": null,
  "discountText": null,
  "minOrderQuantity": 10,
  "minOrderUnit": "meters",
  "moqText": "Min. order: 10 meters",
  "soldCount": 1548,
  "soldText": "1,548 sold",
  "supplierName": "Shenzhen Chengjie Lighting Co., Ltd.",
  "supplierId": "274667237",
  "supplierCountry": "CN",
  "supplierYears": 3,
  "supplierUrl": "https://szcjlighting.en.alibaba.com/",
  "supplierProductsUrl": "https://szcjlighting.en.alibaba.com/company_profile.html",
  "rating": 4.5,
  "reviewCount": 387,
  "supplierServiceScore": 4.5,
  "shippingScore": 4.6,
  "productScore": 4.5,
  "starLevel": 5,
  "certifications": ["Declaration of Conformity", "UKCA", "EMC", "RoHS", "CE"],
  "tags": ["lowest_180_price", "x_day_dispatch", "easy_return", "ag"],
  "imageUrl": "https://s.alicdn.com/@sc04/kf/He7e2d61b751841189911ee53db623697c.png_300x300.png",
  "images": ["https://s.alicdn.com/@sc04/kf/He7e2d61b751841189911ee53db623697c.png_300x300.png", "..."],
  "searchKeyword": "led light",
  "page": 1,
  "position": 1,
  "scrapedAt": "2026-08-09T22:46:11.031Z"
}
```

Alibaba shows prices as display strings — `"$0.64-0.71"` for a quantity range, `"$0.80"` for a flat
price. Those are parsed into `priceMin` and `priceMax` so you can sort and filter numerically, and
the original string is kept in `priceText`. 55% of products quote a range rather than one price.
`minOrderQuantity` is likewise split out of prose like `"Min. order: 10 meters"`.

#### Field coverage

Measured over 730 real rows from live runs, not estimated:

| Field | Present |
|---|---|
| `productId`, `title`, `productUrl` | 100% |
| `priceMin`, `priceMax`, `priceText`, `currency` | 100% |
| `minOrderQuantity`, `minOrderUnit`, `moqText` | 100% |
| `supplierName`, `supplierId`, `supplierCountry`, `supplierYears` | 100% |
| `supplierUrl`, `supplierProductsUrl`, `imageUrl`, `images`, `starLevel` | 100% |
| `rating`, `reviewCount`, `supplierServiceScore`, `shippingScore`, `productScore` | 92% |
| `tags` | 76% |
| `soldCount`, `soldText` | 60% |
| `certifications` | 41% |
| `promotionPrice`, `discountText` | 8% |

The partial fields are partial because Alibaba genuinely does not show them on every card: a supplier
with no reviews yet has no rating, a product with no sales has no sold count, and most listings
advertise no certifications and no promotion. Missing values are `null` and empty lists are `[]` —
nothing is invented to fill a column.

### Input

| Field | What it does |
|---|---|
| `searchQueries` | Search terms, one per line. Each is walked separately and results are de-duplicated across all of them. |
| `startUrls` | Or paste Alibaba.com search URLs — the term is read out of the URL. |
| `maxItems` | Total products across all terms. Default 50. |
| `currency` | USD, EUR, GBP, JPY, INR, CAD, AUD, BRL, RUB or SGD. |
| `minPrice` / `maxPrice` | Price bounds, in the currency you chose. |
| `maxMoq` | Maximum minimum-order quantity. |
| `minSupplierYears` / `minReviewCount` / `minRating` | Supplier quality bounds. |
| `supplierCountries` | Two-letter codes, e.g. `["CN","HK"]`. |
| `maxPagesPerQuery` | Page ceiling per term, 40 products per page. |

```json
{
  "searchQueries": ["led light", "solar panel"],
  "maxItems": 2000,
  "currency": "EUR",
  "maxMoq": 100,
  "minSupplierYears": 5
}
```

Run it with no input and you get one labelled sample row, uncharged, so you can see the shape before
spending anything.

#### About the currency setting

Alibaba converts prices to whichever currency the request asks for, and if nothing asks it follows
the exit address's country — which is how a dataset silently ends up mixing currencies. This actor
always pins one. The pin converts rather than relabels: joining the same products across two runs put
CAD/USD at a median 1.4158 and EUR/USD at 0.8767, both real exchange rates.

### Limits

Read this part before you build on it.

- **Results are a sampled feed, not a fixed catalogue page.** Alibaba personalises this endpoint per
  request, so two identical runs overlap heavily but do not match, and consecutive pages repeat about
  15% of their rows. Duplicates are removed on `productId` and are never charged, which is why a run
  can return slightly fewer rows than `maxItems` when a term runs thin.
- **Depth per term is limited by diminishing returns, not by a hard wall.** A 25-page drain of one
  term returned 823 unique products, with new rows per page decaying from 40 to about 27. To get
  more products, add more search terms rather than paging deeper — narrower terms return genuinely
  different products.
- **No quantity price ladder, and no Trade Assurance or verified-supplier flags.** Alibaba's search
  response does not carry them. An earlier version of this actor read a listing route that did;
  Alibaba retired that route, and inventing the fields from a range would be a guess. `priceMin` and
  `priceMax` are the ends of the quantity ladder, which is what most people wanted from it.
- **No per-product detail fetch.** Everything above comes out of the search response, which is why
  1,000 products is about 30 requests instead of 1,030 — and why it can be priced this low and still
  be profitable. Full specification tables, description images and per-quantity break points
  live on the product page and are not included.
- **Prices are ex-works unit prices.** No shipping, no duty, no tax.
- **Alibaba.com is overwhelmingly Chinese.** A 730-product sample was 97.4% CN and 1.9% HK, so
  `supplierCountries` filters for other countries return very little.
- **`tags` are Alibaba's own internal chip names** (`free_shipping`, `easy_return`, `x_day_dispatch`,
  `lowest_180_price`). They are passed through verbatim rather than renamed into something prettier
  that might not mean the same thing.

### FAQ

**Do I need an Alibaba account?**
No. Nothing to log in to, no API key, and nothing to solve.

**How fast is it?**
300 products in 69 seconds in a cloud run across three search terms.

**What does it cost to scrape 1,000 products?**
$0.85, plus the $0.001 start fee.

**Is this the same as 1688?**
No. Alibaba.com is the English-language export site with MOQs aimed at importers. 1688 is Alibaba's
domestic Chinese marketplace, generally cheaper and with lower minimums, aimed at buyers inside China.

**Can I export to CSV or Excel?**
Yes — Apify exports the dataset as JSON, CSV, Excel or XML, with a REST endpoint for the same data.

**Is this affiliated with Alibaba?**
No. It reads public listing data. Check Alibaba's terms and your own local rules before using the
output commercially.

### How it works

Alibaba's anti-bot gate is applied per URL path, not per host — which is the detail that makes this
actor possible. The same `www.alibaba.com` that answers this scraper normally returns an 89 KB
challenge page to `/trade/search`, and the old SEO listing route `/wholesale/<slug>.html` was retired
and now serves a "404-Error" page with no data in it at all. The mobile product route is challenged
unconditionally: 31 combinations of headers, cookies and referers across datacenter, static-ISP,
mainland-Chinese and direct addresses all returned the same byte-identical challenge.

This scraper talks to the JSON search endpoint the site's own front end calls. It needs no login, no
token, no signature, no cookie handshake and no browser, and it returns 40 fully-populated products
per request. Two measured details shape the implementation: each exit address is good for exactly ten
requests before it is challenged, so addresses are rotated every eight; and a challenge arrives as
HTTP 200, so blocks are detected by inspecting the body rather than the status code.

No headless browser is launched and no residential bandwidth is billed — plain datacenter addresses
are served normally here, and rotation rather than expensive addresses is what buys the reliability.

# Actor input Schema

## `searchQueries` (type: `array`):

What to look for on Alibaba.com, one term per line — for example "led light" or "stainless steel water bottle". Each term is walked separately and results are de-duplicated across all of them.

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

Optional. Paste Alibaba.com search or listing URLs instead of typing terms, for example https://www.alibaba.com/trade/search?SearchText=led%20light. The search term is read out of the URL. Works alongside the field above.

## `maxItems` (type: `integer`):

Hard cap on products returned across all search terms. You are charged per product returned, so this is your budget cap. Duplicates are never charged.

## `currency` (type: `string`):

Alibaba converts its prices to whichever currency the request asks for. Without this pin the currency silently follows the exit address's country and one dataset ends up mixing currencies. Every option here was verified live to convert prices, not just relabel them.

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

Keep only products whose price range reaches this value, in the currency chosen above.

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

Keep only products whose price range starts at or below this value.

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

Keep only products you can order in quantities at or below this number. Units differ per product (pieces, sets, meters, rolls), so this compares the number only.

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

Keep only suppliers who have been selling on Alibaba at least this many years. Present on 100% of products.

## `minReviewCount` (type: `integer`):

Keep only products whose supplier has at least this many reviews. About 6% of products carry no review data at all and are dropped by any value above 0.

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

Keep only products rated at or above this, out of 5.

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

Two-letter country codes, for example CN, HK, IN, US, VN. Alibaba.com is overwhelmingly Chinese: a 480-product sample was 97.3% CN and 1.9% HK, so narrow filters here return very little.

## `maxPagesPerQuery` (type: `integer`):

Page ceiling per term, 40 products per page. Consecutive pages overlap by roughly 15%, so a page adds about 33 new products on average and fewer as you go deeper. Raise this only if you want depth on one term; searching more terms returns more unique products per request.

## `requestDelayMs` (type: `integer`):

Minimum gap between requests. The actor already spreads a run across many exit addresses, so this is rarely needed; raise it if a run ends early with a BLOCKED row.

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

Optional. The actor ships with its own rotating datacenter addresses and needs no configuration. Supply your own proxies here only if you want to use them instead. Apify Residential is deliberately not used — Alibaba serves datacenter addresses normally, and residential bandwidth is billed per GB against ~287 KB per page.

## Actor input object example

```json
{
  "searchQueries": [
    "led light"
  ],
  "startUrls": [],
  "maxItems": 50,
  "currency": "USD",
  "maxPagesPerQuery": 100,
  "requestDelayMs": 500,
  "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 = {
    "searchQueries": [
        "led light"
    ],
    "startUrls": [],
    "maxItems": 50,
    "currency": "USD",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/alibaba-com-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 = {
    "searchQueries": ["led light"],
    "startUrls": [],
    "maxItems": 50,
    "currency": "USD",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/alibaba-com-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "led light"
  ],
  "startUrls": [],
  "maxItems": 50,
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dami_studio/alibaba-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/alibaba-com-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3UQCL0HsYKsudgul0/builds/6YIO0obeecquaiuX4/openapi.json
