# Alibaba Product Scraper - Prices, MOQ & Verified Suppliers (`rel8ble/alibaba-product-search-scraper`) Actor

Scrape Alibaba.com search results by keyword: price range and quantity tiers, MOQ, supplier name, years on Alibaba, Verified/Gold status, rating, country, product URL and images. Price, MOQ, country and verified filters. Fast HTTP-only, no browser.

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

## Pricing

from $1.50 / 1,000 results

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/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: Products, Prices, MOQ & Verified Suppliers

This **Alibaba scraper** turns Alibaba.com search results into clean JSON, CSV or Excel: enter a keyword and get every product's price range, quantity price tiers, MOQ, supplier name, years on Alibaba, Verified / Gold / Trade Assurance status, rating and supplier country, 55 fields per product.
Use it as an **Alibaba product scraper** for sourcing and price research, an **Alibaba supplier scraper** for lead lists, or an unofficial **Alibaba API** you call from your own code, Make, Zapier or n8n.

It reads the same JSON Alibaba's own search page loads, over plain HTTP, with **no headless browser**. A search of 1,000 products takes about 20 seconds and costs very little compute.

### How to use

1. Enter one or more keywords in **Search terms** (e.g. `yoga mat`, `led strip lights`) and optionally set price, MOQ, country or verified-supplier filters.
2. Click **Start**. Each keyword pages through Alibaba search results until your **Max results per search** is reached.
3. Download the results as JSON, CSV or Excel from the **Output** tab, or fetch them through the Apify API.

### What you get

- **Product**: title, product URL, main image plus the image gallery, category, "sold" count, video flag, product certifications (CE, FCC, RoHS, ...).
- **Price**: min and max unit price in USD, the price text Alibaba shows, the full **quantity price ladder** (e.g. 50-999 pcs $11, 1,000-4,999 pcs $10, ...), promotion price and discount when there is one, shipping cost and delivery estimate when Alibaba shows them.
- **MOQ**: minimum order quantity as a number, its unit ("pieces", "meters", "sets"), and the original text.
- **Supplier**: company name, store URL and profile URL, country, **years on Alibaba**, **Verified supplier** / Verified Pro / Gold supplier / Trade Assurance flags, rating (out of 5) with review count, and sub-scores for product quality, service and on-time shipment.
- **Supplier depth**: response rate and response time, staff count, factory size, main products, export markets, company certifications (ISO, BSCI, ...) and who verified them (SGS, TÜV, ...).
- **Sponsored flag**: `isAd` marks paid listings, so you can keep them or drop them with `includeAds: false`.
- **Pagination and dedup**: pages through the results until your `maxResultsPerSearch`, removing duplicates.

### Use cases

- Sourcing: build a shortlist of verified, low-MOQ suppliers for a product in minutes
- Price research: compare unit prices and quantity breaks across hundreds of suppliers
- Dropshipping and Amazon FBA product research
- Supplier lead lists and market maps by country, category or certification
- Monitoring: schedule daily runs and track prices, sold counts and new suppliers over time

### Input

| Field | Default | Description |
|---|---|---|
| `searchTerms` | `led strip lights` | Keywords, one per line: `"yoga mat"`, `"led strip lights"`, `"custom tote bags"`. Alibaba search URLs work too. |
| `maxResultsPerSearch` | 100 | Unique products per keyword. 0 = everything Alibaba serves (about 960). |
| `minPrice` / `maxPrice` | - | Unit price filter in USD (whole dollars) |
| `maxMoq` | - | Only products with an MOQ at or below this number |
| `verifiedSuppliersOnly` | false | Only suppliers with Alibaba's third-party "Verified" badge |
| `supplierCountry` | - | 2-letter code: `CN`, `IN`, `VN`, `TR`, `PK`, `US`, ... |
| `includeAds` | true | Keep sponsored listings (flagged with `isAd`) |
| `proxyConfiguration` | Apify Proxy | Switch to RESIDENTIAL if you ever see blocks |

### Input example

```json
{
    "searchTerms": ["yoga mat", "resistance bands"],
    "maxResultsPerSearch": 200,
    "maxMoq": 100,
    "verifiedSuppliersOnly": true
}
```

### Output example

One dataset item per product. This one is from a real run for "yoga mat" (arrays shortened):

```json
{
    "searchTerm": "yoga mat",
    "position": 7,
    "productId": "1601583212388",
    "title": "High Quality Eco-Friendly Premium Extra Large Yoga Gym Mat Custom Logo New Design Stackable PU Natural Nonslip Black Rubber",
    "url": "https://www.alibaba.com/product-detail/High-Quality-Eco-Friendly-Premium-Extra_1601583212388.html",
    "image": "https://s.alicdn.com/@sc04/kf/H8177d380a8cd4ce69ddb0c1c54e2a77bL.jpg",
    "images": ["https://s.alicdn.com/@sc04/kf/H8177d380a8cd4ce69ddb0c1c54e2a77bL.jpg", "..."],
    "priceMin": 8,
    "priceMax": 11,
    "priceText": "US $8.00-$11.00",
    "currency": "USD",
    "priceUnit": "piece",
    "priceTiers": [
        { "minQuantity": 50, "maxQuantity": 999, "price": 11, "unit": "pieces" },
        { "minQuantity": 1000, "maxQuantity": 4999, "price": 10, "unit": "pieces" },
        { "minQuantity": 5000, "maxQuantity": 9999, "price": 9, "unit": "pieces" },
        { "minQuantity": 10000, "maxQuantity": null, "price": 8, "unit": "pieces" }
    ],
    "promotionPriceMin": null,
    "promotionDiscountPercent": null,
    "moq": 50,
    "moqUnit": "pieces",
    "moqText": "50 pieces",
    "soldCount": 378,
    "shippingCost": null,
    "deliveryEstimate": null,
    "leadTimeDays": 35,
    "category": "Yoga Mats",
    "categoryId": "201273273",
    "hasVideo": true,
    "productCertifications": [],
    "isAd": false,
    "supplierName": "DONGGUAN TONGTIANXIA RUBBER CO., LTD.",
    "supplierId": "200016345",
    "supplierUrl": "https://ttxrubber.en.alibaba.com/",
    "supplierProfileUrl": "https://ttxrubber.en.alibaba.com/company_profile.html",
    "supplierCountry": "China",
    "supplierCountryCode": "CN",
    "supplierYears": 19,
    "verifiedSupplier": true,
    "verifiedSupplierPro": false,
    "goldSupplier": true,
    "tradeAssurance": true,
    "supplierRating": 4.8,
    "supplierReviewCount": 25,
    "ratingProductQuality": 4.8,
    "ratingSupplierService": 4.8,
    "ratingOnTimeShipment": 4.7,
    "responseRate": "99.9%",
    "responseTime": "≤1h",
    "supplierEmployees": 130,
    "supplierFactorySizeSqm": 33000,
    "supplierMainProducts": "Yoga Mat, Mouse Pad, Desk Pad, Bar Mat, Play Mat",
    "supplierExportCountries": ["United States", "Brazil", "Canada", "Germany", "..."],
    "supplierCertifications": ["ISO", "FSC"],
    "supplierVerifiedBy": "SGS",
    "searchPage": 1,
    "scrapedAt": "2026-09-24T05:16:05.270Z"
}
```

The dataset has three ready-made views: **Overview** (image, title, price, MOQ, supplier, verified, rating, link), **Suppliers** (all trust signals) and **Prices** (price range, quantity tiers, MOQ, promotions).

#### Field fill rates (real test run: 1,200 products across 4 keywords)

| Field | Fill rate |
|---|---|
| title, url, image, priceMin/priceMax, moq, supplierName, supplierYears, supplierCountry, category | 100% |
| responseRate, supplierMainProducts | 99-100% |
| priceTiers | 90% (the rest have one flat price) |
| supplierRating, supplierReviewCount > 0 | 88% (newer suppliers have no reviews yet) |
| verifiedSupplier = true | 57% (the rest are not verified; the field itself is always filled) |
| supplierEmployees, supplierExportCountries | about 49% (only when the supplier publishes them) |
| soldCount | 47% (only when Alibaba shows a "sold" badge) |
| productCertifications / supplierCertifications | 32% / 26% |
| shippingCost, deliveryEstimate | 23% (only when Alibaba shows them for your region) |

### Pricing

**Pay per result: $1.50 per 1,000 results** (one result = one product saved to the dataset).

- 1,000 results = $1.50
- 10,000 results = $15.00

Apify platform usage stays very low because no browser runs (one request returns 48 products). Duplicates and failed requests are never charged. If you set a maximum cost per run, the scraper stops cleanly when it reaches it. The Apify free plan includes $5 of monthly credit, enough to try it.

### Integrations

- **Make, Zapier and n8n**: run the actor and pass the products on to any app.
- **Google Sheets**: export the dataset straight to a spreadsheet.
- **Apify API**: start runs and download results over REST, or with the JavaScript and Python API clients.
- **Webhooks**: get notified when a run finishes.
- **MCP for AI agents**: the Apify MCP server (https://mcp.apify.com) lets Claude, ChatGPT, Cursor and other agents call this Alibaba scraper as a tool.

### Limits (read before large runs)

- **About 960 unique products per keyword.** Alibaba serves 20 pages of 48 results for any search, however many matches it reports. For more coverage, use more specific keywords (`"yoga mat tpe"`, `"yoga mat cork"`, ...) or the price/MOQ/country filters to slice the results.
- **Alibaba matches loosely.** A very narrow or misspelled keyword still returns related products instead of zero results. Check the titles if precision matters.
- **Prices are USD list prices** from the search card. Final prices depend on quantity, options and shipping; the quantity tiers show how price drops with volume.
- **Supplier location is country level.** Province and city are on the supplier's profile page, which this actor doesn't open (it keeps runs fast and cheap).
- **Search results only.** Full product specifications, variant/SKU lists and review texts are not included in this version.
- `minPrice` / `maxPrice` take whole dollars.

### FAQ

**Does it need a browser, cookies or an Alibaba account?**
No. It makes plain HTTPS requests to the JSON endpoint Alibaba's search page itself uses. No login.

**Which proxy should I use?**
The default Apify Proxy works. If the log shows repeated "Blocked" retries, switch the proxy group to RESIDENTIAL. Blocked requests are retried automatically on a fresh session with a new IP.

**What does "Verified supplier" mean?**
`verifiedSupplier: true` means the supplier's company information was checked on site by a third-party inspection company (the company is in `supplierVerifiedBy`, e.g. SGS or TÜV). It's Alibaba's strongest trust badge in search results.

**Why did a search return fewer results than I asked for?**
Alibaba ran out of pages for that keyword or filter combination. The `RUN_SUMMARY` record in the key-value store shows the stop reason and the number of matches Alibaba reported for each search.

**Can I track prices over time?**
Yes. Schedule the actor and join runs on `productId`, which is stable.

**Is it legal to scrape Alibaba?**
This actor collects only publicly available product and business data shown in Alibaba search results, no login and no personal data. You're responsible for using the data in line with Alibaba's terms of service and privacy laws such as GDPR. This is not legal advice; if you're unsure, check with a lawyer.

**How does it avoid blocks?**
It sends browser-like request headers through Apify Proxy with a pool of rotating sessions. A blocked request (HTTP 401/403/429, captcha or non-JSON reply) retires that session and is retried on a new IP, up to 6 retries by default with backoff. If blocks persist, switch the proxy group to RESIDENTIAL.

**What are the limits?**
About 960 unique products per keyword (Alibaba serves 20 pages of 48), search-result fields only (no full product specs, SKUs or review texts), USD list prices, and country-level supplier location. See the Limits section above.

### How it works (for developers)

Alibaba's search page fetches its product grid as JSON from `open-s.alibaba.com/openservice/galleryProductOfferResultViewService`. The actor calls that endpoint directly, 48 products per request, with the same filter parameters the site uses (`pricef`/`pricet`, `moqf`/`moqt`, `assessmentCompany`, `Country`). Every field is read defensively, so a malformed record just has fewer fields and the run doesn't crash. Non-JSON or captcha responses retire the session and retry on a new IP with backoff.

Run it locally:

```bash
npm install
npm test                                  # parser tests on a saved real response
APIFY_LOCAL_STORAGE_DIR=./storage node src/main.js   # input in storage/key_value_stores/default/INPUT.json
```

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Alibaba.com, one per line, e.g. "yoga mat", "led strip lights", "custom tote bags". You can also paste an Alibaba search URL (https://www.alibaba.com/trade/search?SearchText=...). If left empty, the actor runs a demo search for "led strip lights".

## `maxResultsPerSearch` (type: `integer`):

Stop each keyword after this many unique products, e.g. 20 for a quick test or 500 for a full shortlist. 0 = as many as Alibaba will page through (about 960 per keyword). You pay per product saved.

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

Only products whose unit price reaches at least this amount, in whole US dollars (e.g. 5). Leave empty for no limit.

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

Only products priced at or below this amount, in whole US dollars (e.g. 20). Leave empty for no limit.

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

Only products whose minimum order quantity (MOQ) is at most this many units, e.g. 100. Great for finding low-MOQ suppliers. Leave empty for no limit.

## `verifiedSuppliersOnly` (type: `boolean`):

Only return products from suppliers checked on site by a third-party inspection company such as SGS or TÜV (Alibaba "Verified" badge).

## `supplierCountry` (type: `string`):

2-letter country code of the supplier, e.g. CN (China), IN (India), VN (Vietnam), TR (Turkey), US. Leave empty for all countries.

## `includeAds` (type: `boolean`):

Alibaba mixes paid (sponsored) listings into search results. They are real products and are flagged with isAd: true. Turn off to keep organic results only.

## `maxConcurrency` (type: `integer`):

How many requests run in parallel (1-20). Different keywords run in parallel; pages within one keyword run in order. The default of 5 is fine for most runs.

## `maxRequestRetries` (type: `integer`):

How many times a failed page is retried (0-20). Blocked requests are retried on a new proxy session with a fresh IP.

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

Apify Proxy (default) works for most runs. If the log shows repeated "Blocked" retries, switch to the RESIDENTIAL proxy group.

## Actor input object example

```json
{
  "searchTerms": [
    "yoga mat",
    "led strip lights"
  ],
  "maxResultsPerSearch": 20,
  "verifiedSuppliersOnly": false,
  "includeAds": true,
  "maxConcurrency": 5,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

All products found, with price range, MOQ, supplier and rating.

## `summary` (type: `string`):

Per-search counts and stop reasons.

# 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 = {
    "searchTerms": [
        "yoga mat",
        "led strip lights"
    ],
    "maxResultsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/alibaba-product-search-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 = {
    "searchTerms": [
        "yoga mat",
        "led strip lights",
    ],
    "maxResultsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/alibaba-product-search-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 '{
  "searchTerms": [
    "yoga mat",
    "led strip lights"
  ],
  "maxResultsPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rel8ble/alibaba-product-search-scraper --silent --output-dataset

```

## MCP server setup

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