# Alibaba Products Scraper — Suppliers, Prices & MOQ (`khadinakbar/alibaba-products-scraper`) Actor

Scrape Alibaba.com B2B products by keyword or URL — tier prices, MOQ, supplier name, years, country, gold status, response rate, GMV, and reviews. HTTP-only, MCP-ready.

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

## Pricing

from $3.00 / 1,000 product scrapeds

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 Products Scraper — Suppliers, Prices & MOQ

Scrape Alibaba.com B2B products by keyword or URL and receive one record per product card. Each record can include tier prices, minimum order quantity, supplier name, supplier country, supplier years on Alibaba, Gold Supplier status, response rate, GMV, review score, review count, and related listing signals. The actor accepts a free-text product keyword, multiple keywords, or Alibaba search and showroom URLs, and it returns structured dataset rows that you can filter, export, or pass into an Apify Actor workflow or Apify MCP.

### Best fit and connected workflows

This actor fits workflows that start with Alibaba product discovery and continue into supplier review, market analysis, or agent-driven research:

- sourcing teams building a shortlist from one or more product keywords
- procurement research comparing tier prices and minimum order quantities
- market-intelligence pipelines tracking trust signals and review data over time
- AI agents that need structured Alibaba product cards as retrieval input
- follow-up supplier and listing analysis with [Alibaba Listings Scraper - Suppliers, MOQ & Price](https://apify.com/khadinakbar/alibaba-listings-scraper)

A practical workflow is to discover products here first, then move to the linked listings scraper when the next step centers on supplier-listing detail and supplier profile review.

### Practical scenario

Rina is reviewing reusable packaging options for a new sourcing brief. She starts with the keyword `stainless steel water bottle`, keeps `enrichDetails` off because the listing cards already include price, MOQ, supplier, and review fields, and sets `maxResults` for a focused sample. The returned records include `title`, `priceText`, `minOrder`, `supplierName`, `supplierCountry`, `supplierYears`, `reviewScore`, and `reviewCount`. Rina compares suppliers, opens `productUrl` for the most relevant items, and uses `supplierUrl` to continue supplier review.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | Free-text product keyword searched on Alibaba.com. One keyword typically returns one showroom page with about 38 products. |
| `searchQueries` | array of strings | Multiple product keywords in one run. Use this for broader volume across related product terms. |
| `startUrls` | array of strings | Alibaba search or showroom URLs to scrape directly. Each URL is normalized to a showroom listing path. |
| `maxResults` | integer | Maximum total product cards across all keywords and URLs. Range 1-5000. This also acts as the product event cap. |
| `enrichDetails` | boolean | Visits each product detail page to add description and spec attributes. |
| `customProxyUrls` | array of strings | Your own proxy URLs, such as residential proxy endpoints. |
| `proxyConfiguration` | object | Apify proxy settings used when `customProxyUrls` is empty. |

#### Focused input example

```json
{
  "searchQueries": ["led lights", "solar panel", "yoga mat"],
  "maxResults": 100,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Valid start URL example

```json
{
  "startUrls": ["https://www.alibaba.com/showroom/led-lights.html"],
  "maxResults": 38,
  "enrichDetails": false
}
```

### Output

Results are written to the run's default dataset. Each dataset item represents one Alibaba product card collected from the search or showroom pages. The dataset can be downloaded as JSON, CSV, Excel, HTML, or RSS.

| Field | Type | Description |
|---|---|---|
| `productId` | string or null | Alibaba product or offer identifier. |
| `title` | string or null | Product title from the listing card. |
| `productUrl` | string or null | Canonical product-detail URL for the item. |
| `image` | string or null | Main product image URL. |
| `hasVideo` | boolean | Indicates whether the listing includes a video. |
| `priceText` | string or null | Raw price text from the listing card. |
| `priceMin` | number or null | Parsed minimum price value. |
| `priceMax` | number or null | Parsed maximum price value. |
| `currency` | string or null | Currency code when detected. |
| `minOrder` | string or null | Minimum order quantity text. |
| `unit` | string or null | Order unit text. |
| `supplierName` | string or null | Supplier or company name shown on the listing card. |
| `supplierId` | string or null | Supplier identifier. |
| `supplierUrl` | string or null | Supplier company profile URL. |
| `supplierCountry` | string or null | Supplier country. |
| `supplierCountryCode` | string or null | ISO country code for the supplier country. |
| `supplierYears` | integer or null | Years the supplier has been on Alibaba. |
| `isGoldSupplier` | boolean | Gold Supplier badge flag. |
| `isAssessedSupplier` | boolean | Assessed Supplier badge flag. |
| `provideProducts` | string or null | Other product lines the supplier offers. |
| `tradeAssurance` | boolean | Trade Assurance flag. |
| `responseRate` | string or null | Supplier response rate. |
| `supplierHistoryGmv` | string or null | Historical GMV in the source format. |
| `supplierHistoryGmvUsd` | number or null | Historical GMV parsed in USD. |
| `supplierHistoryOrderCount` | integer or null | Historical order count. |
| `transactionLevel` | integer or null | Alibaba transaction level. |
| `reviewScore` | number or null | Product review score. |
| `reviewCount` | integer or null | Product review count. |
| `isAd` | boolean | Indicates a promoted listing. |
| `keyword` | string or null | Input keyword associated with the record. |
| `page` | integer or null | Listing page number. |
| `scrapedAt` | string or null | Timestamp when the record was scraped. |

#### Illustrative output record

```json
{
  "productId": "1601234567890",
  "title": "Stainless Steel Water Bottle",
  "productUrl": "https://www.alibaba.com/product-detail/example.html",
  "image": "https://example.com/image.jpg",
  "hasVideo": false,
  "priceText": "US $0.36-$0.39",
  "priceMin": 0.36,
  "priceMax": 0.39,
  "currency": "USD",
  "minOrder": "100 pieces",
  "unit": "piece",
  "supplierName": "Example Trading Co., Ltd.",
  "supplierId": "seller123",
  "supplierUrl": "https://example.com/supplier",
  "supplierCountry": "China",
  "supplierCountryCode": "CN",
  "supplierYears": 8,
  "isGoldSupplier": true,
  "isAssessedSupplier": false,
  "provideProducts": "Bottles, tumblers, mugs",
  "tradeAssurance": true,
  "responseRate": "98.0%",
  "supplierHistoryGmv": "US $1.2M",
  "supplierHistoryGmvUsd": 1200000,
  "supplierHistoryOrderCount": 1540,
  "transactionLevel": 3,
  "reviewScore": 4.8,
  "reviewCount": 126,
  "isAd": false,
  "keyword": "stainless steel water bottle",
  "page": 1,
  "scrapedAt": "2026-07-27T00:00:00.000Z"
}
```

### How it works

This actor reads Alibaba's embedded result data from search or showroom pages and turns each product card into a structured dataset item. The implementation is HTTP-only and uses the embedded page JSON rather than browser rendering, which keeps the output centered on listing fields already present in the response.

If you already have an Alibaba search or showroom URL, place it in `startUrls`. If you want broader coverage from product keywords, use `searchQuery` or `searchQueries`. The `maxResults` field sets the total product-card cap across all inputs. When `enrichDetails` is enabled, the actor also visits product detail pages to add description and spec attributes.

### Pricing

This actor uses Pay per event, plus Apify platform usage for compute and proxy costs. Open the live Pricing tab on Apify for the current totals before each run.

The charged events in the live contract are:

- Actor start
- Product scraped
- Product enriched

Event-count example: if you scrape one hundred products with enrichment turned off, the execution includes one Actor start event and one hundred Product scraped events. If you enrich those same one hundred products, each enriched product adds one Product enriched event.

### Use with AI agents (MCP)

This actor is available through Apify MCP as a tool for retrieving Alibaba product records from a keyword or URL query. The exact Actor identity is `khadinakbar/alibaba-products-scraper`.

Tool description: retrieve Alibaba product cards from search or showroom pages and return structured listing data for each product record, including price, MOQ, supplier profile fields, and review signals.

> Find Alibaba B2B product cards for the keyword "solar panel". Return the dataset rows with price, MOQ, supplier name, supplier country, supplier years, Gold Supplier status, response rate, GMV, and review fields, then summarize the records for sourcing review.

Output interpretation: each dataset row is one product card from Alibaba search or showroom listings. Provenance comes from the source listing data itself, and the `keyword`, `page`, and `scrapedAt` fields help trace where each record came from. Scope is controlled by your input keywords or URLs and the `maxResults` value. When you use multiple keywords, the dataset can include records from all of them in one run. `maxResults` also sets your practical product-event count for Pay per event billing. Pagination is represented by the `page` field when it is present.

### API example

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

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

const run = await client.actor('khadinakbar/alibaba-products-scraper').call({
  searchQuery: 'led lights',
  maxResults: 20,
  enrichDetails: false,
});

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

Set `APIFY_TOKEN` in your environment before running the example. The dataset readback returns the scraped Alibaba product records from the run's default dataset.

### Best results and outcome guidance

Use `searchQueries` when you want several related product keywords in one run, such as category variants or naming variations. Use `startUrls` when you already have an Alibaba search or showroom URL and want that exact listing path scraped. Keep `maxResults` aligned with the number of product cards you want to collect across all inputs. Enable `enrichDetails` when your workflow needs description and spec attributes from product detail pages in addition to listing-card fields. For supplier-listing follow-up work, move to the linked Alibaba Listings Scraper after product discovery.

### Design note

I found that the dataset schema includes both `priceText` and parsed numeric fields like `priceMin` and `priceMax`, which makes the same record useful for display and quantitative filtering.

### FAQ

**How should I choose between `searchQuery` and `startUrls`?**\
Use `searchQuery` for a product keyword and `startUrls` for an Alibaba search or showroom URL you already have.

**When should I use `searchQueries`?**\
Use `searchQueries` when you want several product keywords in one run and want the records to accumulate across them.

**What does one output record represent?**\
One record represents one Alibaba product card from the search or showroom listing data.

**When is `enrichDetails` useful?**\
Enable it when you want description and spec attributes from product detail pages in addition to the listing-card fields.

**How does this connect to Alibaba supplier workflows?**\
This actor surfaces product cards, supplier names, supplier trust signals, and review data. When your next step focuses on supplier-listing analysis, use [Alibaba Listings Scraper - Suppliers, MOQ & Price](https://apify.com/khadinakbar/alibaba-listings-scraper).

### Related Actors

- [Alibaba Listings Scraper - Suppliers, MOQ & Price](https://apify.com/khadinakbar/alibaba-listings-scraper) - use this after product discovery when your next step is focused supplier-listing analysis.

### Responsible use

Use this actor for legitimate sourcing, market research, procurement, and analysis workflows. Respect Alibaba's terms, applicable laws, and any contractual obligations tied to the data you collect. Review the live Pricing tab before each run so your input size, `maxResults`, and enrichment choice match your intended event count and Apify platform usage.

# Actor input Schema

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

Free-text product keyword searched on Alibaba.com (e.g. 'led lights', 'stainless steel water bottle'). Each keyword returns one Alibaba showroom page (~38 products). For more volume use searchQueries (multiple keywords). Leave empty if you only use startUrls. NOT a supplier name or product URL.

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

List of product keywords to scrape in one run, e.g. \['led lights', 'solar panel', 'yoga mat']. Each keyword returns ~38 products from its showroom page, so this is how you get volume beyond one keyword. Combined with searchQuery if both are set. NOT URLs — use startUrls for those.

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

Alibaba.com search or showroom URLs to scrape directly, e.g. 'https://www.alibaba.com/trade/search?SearchText=led+lights' or 'https://www.alibaba.com/showroom/led-lights.html'. Each is normalized to the showroom listing path. Use this when you already have a search URL; otherwise use searchQuery. NOT product-detail URLs.

## `maxResults` (type: `integer`):

Maximum total product cards across all keywords/URLs. Defaults to 100. Range 1–5000. Each keyword yields ~38 products, so to reach 100+ supply multiple keywords via searchQueries. Each product is billed once, so this is also your hard cost cap.

## `enrichDetails` (type: `boolean`):

When true, the actor visits each product's detail page to add description and spec attributes (billed extra per enriched product). Slower and more block-prone on Alibaba's anti-bot, so defaults to false. The listing cards already include price, MOQ, supplier and review data without enrichment.

## `customProxyUrls` (type: `array`):

Optional list of your own proxy URLs (e.g. 'http://user:pass@host:port' for DataImpulse / Bright Data residential). Alibaba is IP-reputation sensitive; residential proxies materially raise the success rate. Leave empty to use Apify's datacenter proxy. NOT an Apify proxy group name.

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

Apify proxy settings used when customProxyUrls is empty. Defaults to Apify datacenter proxy. Ignored when customProxyUrls is provided.

## Actor input object example

```json
{
  "searchQuery": "stainless steel water bottle",
  "searchQueries": [
    "led lights",
    "solar panel",
    "yoga mat"
  ],
  "startUrls": [
    "https://www.alibaba.com/showroom/led-lights.html"
  ],
  "maxResults": 100,
  "enrichDetails": false,
  "customProxyUrls": [
    "http://user:pass@gw.dataimpulse.com:823"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All product records found across the search/showroom 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": "led lights",
    "searchQueries": [],
    "startUrls": [],
    "maxResults": 100,
    "customProxyUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQuery": "led lights",
    "searchQueries": [],
    "startUrls": [],
    "maxResults": 100,
    "customProxyUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/alibaba-products-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": "led lights",
  "searchQueries": [],
  "startUrls": [],
  "maxResults": 100,
  "customProxyUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/alibaba-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/kOsFEDHvJlYOEZk2Y/builds/yd1OIWx1NvEk2R7Th/openapi.json