# Alibaba Products Scraper (`automation-lab/alibaba-products-scraper`) Actor

Extract public Alibaba product listings, displayed prices, minimum orders, supplier details, sourcing badges, ratings, and URLs from searches.

- **URL**: https://apify.com/automation-lab/alibaba-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Products Scraper

Extract public **Alibaba products** from keyword searches or supplied Alibaba search URLs.
Get structured listings with displayed price ranges, quantity-price tiers, minimum order quantities, supplier details, sourcing badges, ratings, review counts, images, and product URLs.

Use the Actor for supplier discovery, sourcing research, catalog comparison, spreadsheet exports, and scheduled monitoring.
It works without an Alibaba login and writes normalized product records to the default Apify dataset.

### What does Alibaba Products Scraper do?

The Actor turns one or more Alibaba searches into integration-ready records.
It accepts plain search phrases such as `wireless earbuds` and public search URLs containing `SearchText` or `keywords`.

For every accepted listing, it can provide:

- product identity, title, category, image, and public URL;
- displayed USD price range and quantity-based price tiers;
- displayed minimum order quantity (MOQ);
- supplier name, profile URL, country, years, and response rate;
- Verified Supplier, assessed supplier, Gold Supplier, and Trade Assurance signals;
- displayed rating, review count, sales text, and certificate names;
- source query, page, position, and extraction timestamp.

Results are deduplicated by Alibaba product ID.
The same price, MOQ, supplier, and badge filters apply to keyword and URL inputs.

### Who is it for?

#### Sourcing and procurement teams

Build a shortlist of products and suppliers before deeper qualification or outreach.
Compare displayed prices and MOQs across multiple product searches.

#### Ecommerce operators

Research product categories, supplier availability, and wholesale listing patterns for catalog planning.
Export records to a spreadsheet or data warehouse.

#### Market researchers

Create repeatable snapshots of public Alibaba search results.
Schedule the same input to observe changes in listings, displayed pricing, and supplier signals over time.

#### Developers and data teams

Feed normalized records into internal dashboards, matching pipelines, BI tools, or other Apify integrations.
Use the API or MCP instead of maintaining custom search-page parsing.

### Why use this Alibaba scraper?

- **Two input routes:** use search phrases or existing Alibaba search URLs.
- **Sourcing-focused output:** get MOQ, supplier, badge, price-tier, and certificate fields rather than only titles and links.
- **Consistent filters:** apply price, MOQ, verified-supplier, and Trade Assurance rules across every input route.
- **Bounded pagination:** control both total records and pages per search.
- **Clean failure behavior:** invalid inputs and unexpected upstream responses fail visibly instead of returning false empty datasets.
- **Integration-ready storage:** each product is one typed record in the default Apify dataset.

The Actor extracts public search-listing data.
It does not log in, contact suppliers, place orders, or claim to verify product quality.

### What Alibaba product data can I extract?

| Field group | Example fields | Notes |
| --- | --- | --- |
| Product | `productId`, `title`, `productUrl`, `imageUrl` | Public listing identity and links |
| Search context | `query`, `page`, `position` | Helps compare and monitor result snapshots |
| Category | `category`, `categoryId` | Displayed Alibaba categorization |
| Price | `price`, `minimumPrice`, `maximumPrice`, `currency` | Displayed listing price; not a negotiated quote |
| Quantity pricing | `priceTiers` | Minimum and maximum quantities, unit price, currency, unit |
| MOQ | `minimumOrder`, `minimumOrderText`, `unit` | Numeric and original displayed forms |
| Supplier | `supplierName`, `supplierUrl`, `supplierCountry`, `supplierYears` | Public supplier summary |
| Supplier signals | `verifiedSupplier`, `assessedSupplier`, `goldSupplier`, `tradeAssurance` | Alibaba-displayed signals, not independent endorsements |
| Reputation | `rating`, `reviewCount`, `supplierResponseRate` | May be absent on some listings |
| Activity | `soldCount`, `soldText` | Included only when Alibaba displays it |
| Compliance clues | `certificates` | Displayed certificate names; independently verify claims |
| Audit | `scrapedAt` | ISO 8601 extraction timestamp |

Nullable values remain `null` when Alibaba does not display the corresponding field.
Arrays such as `badges`, `certificates`, and `priceTiers` may be empty.

### How to scrape Alibaba products

1. Open the Actor input page in Apify Console.
2. Enter one or more product phrases in **Search queries**.
3. Optionally add public Alibaba search URLs.
4. Set **Maximum products** for the run.
5. Add price, MOQ, verified-supplier, or Trade Assurance filters if needed.
6. Click **Start**.
7. Open the **Alibaba products** dataset view.
8. Export results as JSON, CSV, Excel, XML, or another supported format.
9. Save the configuration as an Apify Task if you want scheduled snapshots.

A small first run with 10–50 records is useful for checking category fit before increasing the limit.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | string array | `['wireless earbuds']` | Up to 20 product searches |
| `startUrls` | request list | empty | Public `https://*.alibaba.com` search URLs with `SearchText` or `keywords` |
| `maxItems` | integer | `50` | Global saved-product limit from 1 to 10,000 |
| `maxPagesPerQuery` | integer | `20` | Pagination safety limit from 1 to 100 per search |
| `minPrice` | number | unset | Minimum accepted lowest displayed USD price |
| `maxPrice` | number | unset | Maximum accepted lowest displayed USD price |
| `maxMinimumOrder` | integer | unset | Maximum accepted displayed MOQ |
| `verifiedSupplierOnly` | boolean | `false` | Keep suppliers Alibaba marks assessed or verified |
| `tradeAssuranceOnly` | boolean | `false` | Keep listings that display Trade Assurance |

At least one non-empty query or valid Alibaba search URL is required.
`minPrice` cannot be greater than `maxPrice`.

### Example input: one sourcing search

```json
{
  "queries": ["wireless earbuds"],
  "maxItems": 10
}
```

### Example input: supplied Alibaba URL

```json
{
  "queries": [],
  "startUrls": [
    {
      "url": "https://www.alibaba.com/trade/search?SearchText=reusable+water+bottles"
    }
  ],
  "maxItems": 25,
  "maxMinimumOrder": 500
}
```

### Example input: compare supplier searches

```json
{
  "queries": [
    "solar power bank",
    "portable solar panel"
  ],
  "maxItems": 100,
  "maxMinimumOrder": 100,
  "verifiedSupplierOnly": true
}
```

For multiple searches, the Actor allocates the requested total across searches so one broad phrase does not consume the entire result limit before later phrases run.

### Output example

The following shortened record reflects the current output contract.
Supplier text is anonymized for documentation.

```json
{
  "productId": "1601234567890",
  "title": "Wireless Bluetooth Earbuds with Charging Case",
  "productUrl": "https://www.alibaba.com/product-detail/Sample-Product_1601234567890.html",
  "imageUrl": "https://s.alicdn.com/example-product.jpg",
  "query": "wireless earbuds",
  "page": 1,
  "position": 1,
  "category": "Wireless Earphones & Headphones",
  "price": "US $1.30-$2.20",
  "minimumPrice": 1.3,
  "maximumPrice": 2.2,
  "currency": "USD",
  "minimumOrder": 1000,
  "minimumOrderText": "1000 pieces",
  "priceTiers": [
    {
      "minimumQuantity": 1000,
      "maximumQuantity": 4999,
      "price": 2.2,
      "currency": "USD",
      "unit": "pieces"
    }
  ],
  "supplierName": "Example Electronics Co., Ltd.",
  "supplierCountry": "China",
  "supplierYears": 6,
  "verifiedSupplier": true,
  "tradeAssurance": true,
  "badges": ["Verified Supplier", "Trade Assurance"],
  "rating": 4.8,
  "reviewCount": 245,
  "certificates": ["CE"],
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

### How much does it cost to scrape Alibaba products?

This Actor uses pay-per-event pricing:

- a **$0.001 start event** is charged once per run;
- each saved product uses the tiered `item` event;
- on the BRONZE tier, the current product price is **$0.00168 per saved product**.

At the BRONZE tier, example Actor charges are approximately:

| Saved products | Approximate BRONZE Actor charge |
| ---: | ---: |
| 10 | 1.78 cents |
| 100 | 16.90 cents |
| 1,000 | 168.10 cents |

Filters can cause the Actor to inspect more upstream listings than it saves.
Only normalized records accepted into the dataset emit the per-product event.
Your Apify plan determines the active tier and exact event price shown in Console before the run.

### Schedule Alibaba product monitoring

Create an Apify Task with stable searches and filters, then attach a schedule.
Each run is an independent snapshot.
The Actor does not calculate changes itself, so compare datasets downstream using `productId` as the stable key.

Useful monitoring patterns include:

1. detect new product IDs for a sourcing category;
2. compare `minimumPrice`, `maximumPrice`, and `minimumOrder` over time;
3. track when supplier badges or displayed ratings change;
4. alert when a saved product matches your own price and MOQ thresholds.

Do not describe a scheduled result as real-time.
The timestamp records extraction time, while source values can change at any time.

### Export to spreadsheets and data pipelines

From the dataset page, export directly to CSV or Excel for manual sourcing review.
For automated pipelines, consume the dataset API after the run completes.

Recommended keys:

- use `productId` for product-level upserts;
- use `supplierUrl` or supplier name plus country for supplier grouping;
- retain `query`, `page`, and `scrapedAt` for snapshot context;
- keep both numeric and original displayed price/MOQ fields.

Apify integrations can send completed-run data to webhooks, Google Sheets, Make, Zapier, or your own endpoint.

### Use the Apify API with cURL

Set `APIFY_TOKEN` in your environment instead of placing it in source code.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~alibaba-products-scraper/runs?waitForFinish=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["reusable water bottles"],
    "maxItems": 25,
    "verifiedSupplierOnly": true
  }'
```

Use the returned `defaultDatasetId` to download items.

### Use the Apify API with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/alibaba-products-scraper').call({
    queries: ['solar power bank'],
    maxItems: 50,
    maxMinimumOrder: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/alibaba-products-scraper').call(run_input={
    'queries': ['wireless earbuds'],
    'maxItems': 50,
    'tradeAssuranceOnly': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Alibaba Products Scraper with MCP

#### Claude Code setup

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/alibaba-products-scraper"
```

#### Claude Desktop setup

Add this server object to the MCP configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/alibaba-products-scraper"
    }
  }
}
```

#### Cursor setup

Open Cursor MCP settings and add the same `apify` server object and URL shown above.

#### VS Code setup

Open your VS Code MCP configuration and add the same `apify` server object and URL shown above.

Example prompts:

- “Run Alibaba Products Scraper for `wireless earbuds` and return 20 products with MOQ at most 500.”
- “Extract 50 verified-supplier records for `portable solar panel`, then summarize price ranges by supplier country.”
- “Run my saved Alibaba sourcing Task and give me the dataset download link.”

MCP clients still use your Apify account, Actor pricing, and run limits.

### Reliability, retries, and pagination

The Actor uses Alibaba's public structured search service rather than treating a challenged search page as valid data.
Each search page is validated before extraction.

Transient network or upstream failures receive up to three attempts with backoff.
Requests are sequential to avoid unnecessary upstream load.
Pagination stops when:

- `maxItems` is reached;
- `maxPagesPerQuery` is reached;
- the upstream result list ends;
- every configured search has been processed.

If Alibaba returns an unexpected challenge or response shape after retries, the run fails non-zero with a diagnostic message.
This is safer than silently producing an empty dataset.

### Tips for useful sourcing datasets

- Begin broad, inspect category fit, then narrow the phrase.
- Use `maxMinimumOrder` when testing low-volume sourcing options.
- Treat `minimumPrice` as the lowest displayed tier, not a guaranteed quote at your intended quantity.
- Use `verifiedSupplierOnly` and `tradeAssuranceOnly` as screening signals, not final due diligence.
- Run related searches together when you want a balanced comparison dataset.
- Store raw snapshots before transforming them so you can audit future comparisons.
- Keep scheduled workloads bounded with both item and page limits.

### Limitations

- The Actor extracts public Alibaba search-listing data, not every product detail-page attribute.
- Search ranking and counts can vary by time, location, experiments, and Alibaba personalization.
- Displayed prices, MOQs, badges, ratings, certificates, and availability can change or be missing.
- Numeric prices are normalized as USD only when the public response displays USD values.
- Filters reject records with missing required values rather than guessing.
- The Actor does not verify suppliers, certificates, product quality, shipping costs, taxes, inventory, or final transaction terms.
- It does not scrape Alibaba Express, Alibaba Cloud, Alibaba Group corporate information, reviews pages, or private account data.
- A maximum of 20 unique searches and 100 pages per search is supported per run.

### Responsible use and legality

Use this Actor only for lawful purposes and public data you are permitted to collect.
Review Alibaba's terms and applicable rules for your location and use case.
Apply reasonable request volumes and avoid using extracted data for spam, deception, or discriminatory decisions.

Supplier badges and certificate names are source-displayed claims.
Independently verify identity, compliance, product safety, intellectual property rights, samples, payment terms, and trade requirements before purchasing or publishing conclusions.

You are responsible for your inputs, processing, retention, sharing, and compliance with privacy, contract, competition, consumer-protection, and trade laws.

### Troubleshooting

#### The run says I must provide a query or URL

Ensure `queries` contains at least one non-empty string, or add a public Alibaba search URL with `SearchText` or `keywords`.
If using only URLs, set `queries` to an empty array when reusing a prefilled input.

#### My Alibaba URL is rejected

Use an HTTPS URL whose hostname is `alibaba.com` or a subdomain of it.
The URL must represent a search and include `SearchText` or `keywords`.
Product-detail URLs are not search inputs.

#### The dataset contains fewer items than `maxItems`

Filters may reject listings with high or missing prices, MOQs, or supplier signals.
The search may also end before your item limit.
Increase `maxPagesPerQuery` cautiously or loosen filters.

#### The run failed after retries

Open the run log and look for the query and page in the final error.
Alibaba may have changed or temporarily limited its public service.
Retry later only if the error is transient; repeated identical runs are not a substitute for diagnosis.

#### Why is a price different from Alibaba now?

The record is a snapshot of a displayed listing value at `scrapedAt`.
Prices can depend on quantity and can change after the run.
Always open `productUrl` and confirm terms with the supplier.

### FAQ

#### Does the Actor require an Alibaba account?

No.
It extracts public search-listing data and does not authenticate to Alibaba.

#### Can I scrape an existing Alibaba search URL?

Yes.
Add the public URL to `startUrls`; the Actor extracts `SearchText` or `keywords` and applies the same filters as plain queries.

#### Does it scrape product detail pages?

No.
The output is intentionally based on structured search-listing fields to keep runs efficient and focused on sourcing comparison.

#### Are prices final quotes?

No.
They are displayed listing prices and quantity tiers.
Freight, customization, taxes, negotiation, and order quantity can change final cost.

#### Can I monitor changes?

Yes, by scheduling an Apify Task and comparing independent run datasets downstream.
The Actor returns snapshots; it does not itself emit alerts or change records.

#### Are filtered-out products charged as items?

No.
The per-product event is emitted only for normalized records accepted into the default dataset.
The one-time start event still applies to the run.

### Related Automation Lab Actors

- [AliExpress Products & Seller Catalog Scraper](https://apify.com/automation-lab/aliexpress-products-scraper) — compare consumer-marketplace products and seller catalogs.
- [DHgate Product & Supplier Scraper](https://apify.com/automation-lab/dhgate-product-supplier-scraper) — research another public wholesale marketplace using product and supplier records.

These are separate sources with different field contracts.
Choose the Actor whose marketplace matches your sourcing workflow.

# Actor input Schema

## `queries` (type: `array`):

Product searches to run on Alibaba, such as wireless earbuds or reusable water bottles. You can combine these with search URLs.

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

Public Alibaba search result URLs containing SearchText or keywords. Filters below apply to URL and query results alike.

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

Stop after saving this many unique products across all searches.

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

Safety limit for pagination of each search. Each Alibaba page can contain up to 48 products.

## `minPrice` (type: `number`):

Keep products whose lowest displayed USD price is at least this amount.

## `maxPrice` (type: `number`):

Keep products whose lowest displayed USD price is no more than this amount.

## `maxMinimumOrder` (type: `integer`):

Keep products whose displayed minimum order quantity is no more than this number.

## `verifiedSupplierOnly` (type: `boolean`):

Keep products from suppliers that Alibaba marks as assessed or verified.

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

Keep only listings whose supplier displays Alibaba Trade Assurance.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "startUrls": [
    {
      "url": "https://www.alibaba.com/trade/search?SearchText=reusable+water+bottles"
    }
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 20,
  "verifiedSupplierOnly": false,
  "tradeAssuranceOnly": false
}
```

# Actor output Schema

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

All extracted Alibaba product records in the default dataset.

# 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 = {
    "queries": [
        "wireless earbuds"
    ],
    "startUrls": [
        {
            "url": "https://www.alibaba.com/trade/search?SearchText=reusable+water+bottles"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/alibaba-products-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 = {
    "queries": ["wireless earbuds"],
    "startUrls": [{ "url": "https://www.alibaba.com/trade/search?SearchText=reusable+water+bottles" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/alibaba-products-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 '{
  "queries": [
    "wireless earbuds"
  ],
  "startUrls": [
    {
      "url": "https://www.alibaba.com/trade/search?SearchText=reusable+water+bottles"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/alibaba-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/alibaba-products-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/pHeyiUIo9JGc7yAmB/builds/iApXmpxSXqJDxqs8Y/openapi.json