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

Alibaba.com product listings by keyword search or product URL, with optional product details and buyer reviews.

- **URL**: https://apify.com/scraptivo/alibaba-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Alibaba Scraper** collects product listings from [Alibaba.com](https://www.alibaba.com) and turns them into structured data for supplier sourcing, market research, and competitor analysis. Provide keyword searches or direct product URLs, then export titles, prices, MOQs, supplier names, countries, and review scores — with optional full specifications and buyer reviews — to JSON, CSV, Excel, or your preferred integration. Use it to source suppliers at scale, compare price breaks, and monitor the catalog. Pricing starts at **$1.50 per 1,000 products**, with optional product details and reviews billed separately at the same rate.

### What can you automate with Alibaba Scraper?

- **Build supplier shortlists** — search any keyword (for example `spider hoodie`) and export a ready-to-review list with supplier name, country, and years on Alibaba.
- **Compare price and MOQ across listings** — capture price ranges, minimum order quantities, and sold-order counts on every row.
- **Enrich products on demand** — enable product details to add specifications, price tiers, gallery images, and supplier response metrics.
- **Collect buyer reviews** — attach verified buyer feedback, ratings, and reviewer country to each product record.
- **Switch between the main catalog and worldwide supplier results** — set `searchScope` to `products` or `worldwide`.
- **Schedule recurring monitoring** — refresh pricing, sold counts, and new listings in your niche on a daily or weekly cadence.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Sourcing and procurement teams | Comparing MOQs, price breaks, and supplier ratings before contacting factories. |
| E-commerce sellers | Researching supplier options and product pricing for new or existing SKUs. |
| Market researchers | Mapping product availability, suppliers, and review sentiment across a niche. |
| Import/export analysts | Building country-level supplier lists and monitoring catalog changes. |

### What data can you collect from Alibaba.com?

| Data group | Example fields | How it helps |
|---|---|---|
| Listing identity | `title`, `url`, `productId`, `imageUrl` | Identify and deduplicate records with the stable `productId`. |
| Commercial signals | `price`, `moq`, `soldOrder`, `reviewScore`, `reviewCount` | Qualify suppliers without opening each product page. |
| Supplier profile | `companyName`, `countryCode`, `supplierYears` | Filter by supplier location and tenure. |
| Provenance | `searchQuery`, `sourceQuery`, `searchScope`, `page` | Trace which query or URL produced each row. |
| Product details | `details` with attributes, category, `priceTiers`, gallery images, supplier profile | Enrich listings when product details are enabled. |
| Reviews | `reviews` list with rating, text, reviewer country, date, and images | Read buyer feedback when reviews are enabled. |

The `details` object appears only when **Include product details** is enabled; the `reviews` array appears only when **Include product reviews** is enabled. Listing-level data is always returned.

### How to use Alibaba Scraper

1. Open the [Alibaba Scraper](https://apify.com/scraptivo/alibaba-scraper) on Apify.
2. Enter one or more `searchQueries` and/or paste direct Alibaba product URLs in `productUrls`.
3. Choose a `searchScope` (`products` or `worldwide`) and set `maxItems` to cap the run.
4. Optionally enable **Include product details** and **Include product reviews**, and cap reviews with `maxReviews`.
5. Run the Actor and export the dataset to JSON, CSV, or Excel, or connect it to your workflow.

```json
{
    "searchQueries": ["spider hoodie"],
    "searchScope": "products",
    "includeProductDetails": true,
    "includeProductReviews": true,
    "maxItems": 20,
    "maxReviews": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Source and shortlist suppliers for a new product line

1. Run one search per priority keyword (for example `spider hoodie` and `oversized hoodie`) with `maxItems` set to your budget.
2. Keep suppliers that match your required `moq` and `supplierYears`.
3. Re-run the best candidates with **Include product details** and **Include product reviews** enabled to read full specs and buyer feedback.
4. Deduplicate using the stable `productId`, then export to your CRM or sourcing spreadsheet.

### Automate and integrate your results

- **Schedules** — set a daily or weekly schedule per keyword so fast-moving terms refresh more often than long-tail searches. Run `searchScope: worldwide` as a separate schedule when tracking global suppliers.
- **Webhooks** — trigger a webhook on run completion to push fresh listings into your CRM, Google Sheets, or Slack.
- **Exports and API** — download JSON, CSV, or Excel from the Apify Console, or call the Actor from the API. One cURL example:

```shell
curl "https://api.apify.com/v2/acts/scraptivo/alibaba-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["spider hoodie"],
    "includeProductDetails": true,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — within a single run the Actor deduplicates products by `productId`, and reviews by `reviewId`. Across runs, Apify appends new rows; use `productId` (or `url`) as the stable key when merging.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|---|
| `searchQueries` | Array of strings | No\* | — | Product keywords to search on Alibaba.com (e.g. "spider hoodie"). |
| `productUrls` | Array of strings | No\* | — | Direct Alibaba product page URLs, used with or instead of search queries. |
| `searchScope` | String | No | `products` | `products` (main catalog) or `worldwide` (global supplier results). |
| `includeProductDetails` | Boolean | No | `false` | Adds specifications, price tiers, and supplier profile. Charged as `product-details`. |
| `includeProductReviews` | Boolean | No | `false` | Collects reviews shown on each product page. Charged as `product-review` per review. |
| `maxItems` | Integer | No | `0` | Maximum products to extract (`0` = no limit). |
| `maxReviews` | Integer | No | `0` | Maximum reviews across the whole run when reviews are enabled (`0` = every review that loads). |
| `proxyConfiguration` | Proxy object | No | Residential Apify proxy | Proxy settings. Residential proxies are used by default. |

\* Provide at least one `searchQueries` entry or `productUrls` entry.

### Output example

Each dataset item is one product. With details and reviews enabled, a record looks like this:

```json
{
    "recordType": "product",
    "title": "Wholesale Custom Spider Hoodie",
    "url": "https://www.alibaba.com/product-detail/_1234567890.html",
    "productId": "1234567890",
    "imageUrl": "https://s.alicdn.com/example.jpg",
    "price": "$4.50 - $7.20",
    "moq": "100 pieces",
    "soldOrder": "2,000+ sold",
    "companyName": "Guangzhou Apparel Co., Ltd.",
    "countryCode": "CN",
    "supplierYears": "8",
    "reviewScore": 4.8,
    "reviewCount": 214,
    "searchQuery": "spider hoodie",
    "searchScope": "products",
    "page": 1,
    "details": {
        "attributes": { "Material": "Cotton", "Sleeve Style": "Regular" },
        "priceTiers": [{ "quantity": "100-499", "price": "$7.20" }]
    },
    "reviews": [
        { "rating": 5, "text": "Great quality and fast shipping.", "country": "US", "date": "2026-08-12" }
    ]
}
```

### How much does it cost to scrape Alibaba.com?

The Actor uses pay-per-event pricing with three chargeable events, each **$1.50 per 1,000**:

- **`product`** — every product record written to the dataset.
- **`product-details`** — once per product when **Include product details** is on and details are fetched.
- **`product-review`** — once per review when **Include product reviews** is on.

Apify plan discounts apply automatically: Bronze **$1.40**, Silver **$1.30**, Gold **$1.20** per 1,000 events. Platform usage is not charged separately. A listing-only run of 1,000 products costs **$1.50**; enabling details adds **$1.50**, and each review fetched adds to the `product-review` event total.

### Reliability and responsible use

- **Proxy requirement** — the Actor defaults to the Apify residential proxy, which is recommended for consistent Alibaba results.
- **Conditional fields** — `details` and `reviews` appear only when their toggles are enabled; some fields are nullable on the platform.
- **Public data** — the Actor collects publicly visible product, supplier, and review information from Alibaba.com.
- **Responsible use** — only use the data in ways that comply with Alibaba.com's terms of service and applicable law.

### Frequently asked questions

#### Can I scrape Alibaba.com by keyword and by product URL?

Yes. Provide `searchQueries` for keyword search and/or `productUrls` for direct product pages. You can combine both in a single run.

#### Can I schedule the Alibaba Scraper to run automatically?

Yes. Use the **Scheduler** tab in Apify Console to run daily or weekly, and create one schedule per keyword so priority searches refresh more often.

#### What counts as one result?

A product record counts as one `product` event ($1.50 per 1,000). Enabling details adds a `product-details` event per product, and each fetched review adds a `product-review` event.

#### Why are some fields empty?

The `details` and `reviews` fields are only populated when their toggles are enabled. Alibaba also leaves some listing fields unset, so a null value usually means the platform has no data for it.

#### How do I avoid duplicate records?

The Actor deduplicates products by `productId` within a run. Across runs, merge on `productId` (or `url`) to keep only new records.

#### Do I need a proxy?

The Actor works out of the box with the default Apify residential proxy, which is recommended for consistent results on Alibaba.com.

### Related Scraptivo automations

- **[Walmart Scraper](https://apify.com/scraptivo/walmart-scraper)** — collect Walmart product listings with optional details and reviews.
- **[Nike Scraper](https://apify.com/scraptivo/nike-scraper)** — collect Nike.com product listings across marketplaces with size and review data.
- **[H\&M Scraper](https://apify.com/scraptivo/h-and-m-scraper)** — collect H\&M product catalogs with pricing and composition details.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Product keywords to search on Alibaba.com, for example "spider hoodie".

## `productUrls` (type: `array`):

Direct Alibaba product page URLs. Use these with search queries, or on their own.

## `searchScope` (type: `string`):

Products uses the main catalog. Worldwide uses the global-supplier product results.

## `includeProductDetails` (type: `boolean`):

Open each product page and add specifications, price tiers, and supplier profile. Charged once per product as product-details. Off by default.

## `includeProductReviews` (type: `boolean`):

Collect reviews shown on each product page. Charged once per review as product-review. Off by default.

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

Maximum number of products to extract. 0 means no limit.

## `maxReviews` (type: `integer`):

Maximum number of reviews across the whole run when reviews are enabled. 0 means every review that loads.

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

Proxy settings. Residential proxies are used by default.

## Actor input object example

```json
{
  "searchQueries": [
    "spider hoodie"
  ],
  "productUrls": [],
  "searchScope": "products",
  "includeProductDetails": false,
  "includeProductReviews": false,
  "maxItems": 20,
  "maxReviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of product listings and, when enabled, review records.

## `runStats` (type: `string`):

Counts and timestamps for this run.

# 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": [
        "spider hoodie"
    ],
    "productUrls": [],
    "includeProductDetails": false,
    "includeProductReviews": false,
    "maxItems": 20,
    "maxReviews": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/alibaba-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["spider hoodie"],
    "productUrls": [],
    "includeProductDetails": False,
    "includeProductReviews": False,
    "maxItems": 20,
    "maxReviews": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/alibaba-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": [
    "spider hoodie"
  ],
  "productUrls": [],
  "includeProductDetails": false,
  "includeProductReviews": false,
  "maxItems": 20,
  "maxReviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/alibaba-scraper --silent --output-dataset

```

## MCP server setup

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