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

Alibaba scraper for search results as flat rows: product, unit price range, MOQ, supplier name, years on Alibaba, country, review and service scores, badges, images. Filter by price, sort and supplier country. Monitor mode alerts on price and MOQ changes. $1 per 1,000, no login.

- **URL**: https://apify.com/datahamster/alibaba-products.md
- **Developed by:** [Viktor Dubnytskiy](https://apify.com/datahamster) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 16 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 result items

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

An Alibaba scraper that turns a search keyword into flat sourcing rows: product title, unit price range, minimum order quantity, supplier name, years on Alibaba, country, review and service scores, badges and images. Filter by price, supplier country and sort order, or run it as a saved Task in monitor mode to catch new products and price / MOQ changes.

**Try it:** the prefilled example returns 20 rows in about 5 seconds and costs about $0.060. Results cost $3 per 1,000.

### What you get (example output)

Real rows from the example dataset (query `bluetooth speaker`, page 1):

| Field | Example value | What it is |
|---|---|---|
| `productId` | `1601584212085` | Alibaba product id (also `id`) |
| `title` | `USA Shipped TG117 Portable Bluetooth Speaker 24h Shipping US Warehouse ...` | Product title from the search card |
| `priceText` / `priceMin` / `priceMax` | `US $715.00-$780.00` / `715` / `780` | Displayed unit price and the parsed range |
| `moqText` / `moq` / `moqUnit` | `1 set` / `1` / `set` | Minimum order quantity, raw and parsed |
| `supplierName` / `supplierUrl` | `Shenzhen Siruixing Technology Co., Ltd.` / `https://szkeywords.en.alibaba.com/` | Supplier and its Alibaba mini-site |
| `supplierYears` / `countryCode` | `6` / `CN` | Years on Alibaba and supplier country |
| `reviewScore` / `reviewCount` | `4.6` / `176` | Review score and number of reviews (scores are `null` when `reviewCount` is 0) |
| `badges` | `["verified_supplier", "gold_supplier"]` | Supplier flags and Alibaba product/promotion tags |
| `isAd` / `rank` | `true` / `2` | Paid placement flag and position on the result page |

Every row also carries `url`, `currency`, `images[]`, `supplierId`, `productScore`, `supplierServiceScore`, `shippingScore`, `certifications[]`, `query`, `page` and `scrapedAt`.

### Use cases

- **Supplier shortlisting** — pull a whole keyword's result set and sort your own way by price, MOQ, supplier years and review score instead of clicking through Alibaba.
- **Landed-cost and margin modelling** — `priceMin` / `priceMax` and `moq` are already parsed into numbers, so a sourcing spreadsheet needs no text cleaning.
- **Price and MOQ watch** — monitor mode on a schedule reports new products for a keyword and any supplier that moved its price or minimum order.

### Related actors

- [Amazon Price Tracker: Product Scraper by ASIN, Buy Box, Stock](https://apify.com/datahamster/amazon-product-monitor) — track retail prices downstream once you've sourced a supplier.
- [Walmart Product Scraper & Price Monitor (stock, seller, store)](https://apify.com/datahamster/walmart-product-monitor) — same monitor pattern for US retail listings.
- [Etsy Listings Scraper (search, shops, listing details, prices)](https://apify.com/datahamster/etsy-listings) — monitor retail prices for handmade and vintage goods.
- [Flipkart Product Scraper & Price Monitor (search, specs, stock)](https://apify.com/datahamster/flipkart-products) — same pattern for retail prices in the Indian market.
- [Shopify Store Products Scraper (products.json, prices, monitor)](https://apify.com/datahamster/shopify-store-products) — monitor a specific brand's own store instead of a marketplace.

### How it works

Results come from the same search JSON service that alibaba.com's own search page loads, so no browser, no login and no paid proxy tier are needed. One page yields up to 48 products. `priceFrom`, `priceTo` and `countryCode` are applied as Alibaba's own search parameters. Alibaba's service ignores sort order, so `price_asc` and `price_desc` sort the fetched pages by the lowest price, and `orders` keeps Alibaba's default order. In `monitor` mode the run compares price, MOQ and review count against the previous run of the same Task.

### Input

| Field | Meaning | Default |
|---|---|---|
| `queries` | Alibaba search keywords, e.g. `bluetooth speaker`; each is paginated separately | `["bluetooth speaker"]` |
| `priceFrom` / `priceTo` | Unit price bounds in USD, e.g. `10` and `50` | empty |
| `sortBy` | `best_match`, `price_asc`, `price_desc` or `orders` | `best_match` |
| `countryCode` | Supplier country as an ISO code, e.g. `CN`, `IN`, `VN`, `TR` | empty |
| `maxPages` | Result pages per query, 48 products each | `2` |
| `maxItems` | Stop after this many pushed rows | `20` |
| `mode` | `scrape` = every product; `monitor` = only new or changed products since the previous run of this Task | `scrape` |
| `monitorStateId` | State key for monitor mode when not running as a saved Task | empty |
| `webhookUrl` | URL that receives a POST with the change summary in monitor mode | empty |
| `telegramBotToken` / `telegramChatId` | Optional Telegram destination for monitor-mode summaries | empty |

### Pricing

| Event | Price |
|---|---|
| result | $0.001 per product ($1 per 1,000) |
| monitor-check | $0.005 per monitor run |
| change | $0.001 per new/changed product |

Charged only for products actually pushed.

**Found it useful?** A short review on the Store page helps other sourcing teams find this actor and tells us what to improve. If a supplier or price read looks wrong, open an issue on the actor page — issues are answered within a day.

### Why this actor

- **$1 per 1,000 products** — one of the cheapest per-row prices for Alibaba search data.
- **No charge for empty runs** — result events are billed per pushed row, so a run that finds nothing costs nothing in results.
- **Numbers, not strings** — price range and MOQ arrive parsed (`priceMin`, `priceMax`, `moq`, `moqUnit`) next to the raw text.
- **Supplier quality fields included** — years on Alibaba, country, review score and count, service and shipping scores, badges.
- **Monitor mode built in** — new products and price / MOQ changes with webhook or Telegram alerts, no second actor needed.
- **Every run leaves a `RUN_SUMMARY`** record in the key-value store with the reason for an empty result, so a zero-row run is diagnosable.

### Limits

- Price sorting is applied to the pages the run fetched (Alibaba's search service ignores sort order), so raise `maxPages` for a wider price-sorted set. `orders` sorting is not available.
- Product detail pages are not opened: tiered price tables, product attributes and supplier contact details are not included.
- Prices are exactly what Alibaba shows in search, normally a USD per-unit range; they are not converted to another currency.
- A result page holds up to 48 products, but the count varies between requests — Alibaba mixes promotional modules into the grid. Ask for one page more than you strictly need.
- No supplier contact or person-level data is collected.

### FAQ

**How do I get Alibaba prices and MOQ for a whole keyword?** Put the keyword into `queries`, raise `maxPages` (48 products each) and `maxItems`. Every row already contains the parsed price range and minimum order quantity.

**Can I filter suppliers by country?** Yes — `countryCode` takes an ISO code such as `CN`, `IN`, `VN` or `TR` and is passed to Alibaba's own search filter, so results only contain suppliers from that country.

**Does it need a proxy?** No. Since November 2026 the actor reads the JSON service behind Alibaba's search page, which answers without a proxy, so runs are faster and platform usage is lower than with the Web Unblocker the actor used before.

### Changelog

- 2026-11-09: Alibaba moved its search page to a client-rendered shell, so the actor now reads the search JSON service that page loads. No Web Unblocker is needed any more, and runs are faster and cheaper. `priceText` now looks like `US $715.00-$780.00` and `moqText` like `1 set`, while the parsed numbers stay the same. Monitor mode compares the parsed numbers, so the new text format does not mark products as changed. Score fields are `null` when a product has no reviews. Alibaba's service ignores sort order: `price_asc` and `price_desc` are sorted over the fetched pages, and `orders` keeps Alibaba's default order. `certifications` now lists real certificate names.
- 0.1: initial release with search, filters and monitor mode.

***

If this actor is useful, a review on its Apify Store page genuinely helps other buyers find it. Found a bug or need a field that is missing? Open a ticket on the **Issues** tab of the actor and it will be looked at.

# Actor input Schema

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

Alibaba search keywords, e.g. "bluetooth speaker". Each keyword is paginated separately; one result page holds up to 48 products.

## `priceFrom` (type: `integer`):

Lower unit-price bound in USD, passed to Alibaba's own price filter, e.g. 10. Leave empty for no lower bound.

## `priceTo` (type: `integer`):

Upper unit-price bound in USD, passed to Alibaba's own price filter, e.g. 50. Leave empty for no upper bound.

## `sortBy` (type: `string`):

Result order: "best_match" (Alibaba default), "price_asc", "price_desc" or "orders" (most orders first). Example: "best_match".

## `countryCode` (type: `string`):

Supplier country filter as a two-letter ISO code, e.g. "CN", "IN", "VN" or "TR". Leave empty for suppliers from any country.

## `maxPages` (type: `integer`):

How many search-result pages to open per query, e.g. 1. Each page holds up to 48 products.

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

Stop after this many pushed rows, e.g. 20. You are charged only for rows actually pushed.

## `mode` (type: `string`):

"scrape" returns every product found; "monitor" returns only products that are new or whose price, MOQ or review count changed since the previous run of the same saved Task. Example: "scrape".

## `monitorStateId` (type: `string`):

Optional state id when not running as a saved task (monitor mode)

## `webhookUrl` (type: `string`):

URL that receives a POST with the monitor-mode change summary (JSON), e.g. "https://hooks.zapier.com/hooks/catch/123/abc". Leave empty to skip.

## `telegramBotToken` (type: `string`):

Optional Telegram bot token used to send monitor-mode change summaries, e.g. "123456789:AAF...". Leave empty to skip Telegram.

## `telegramChatId` (type: `string`):

Optional Telegram chat id that receives monitor-mode summaries, e.g. "-1001234567890". Required only when telegramBotToken is set.

## Actor input object example

```json
{
  "queries": [
    "bluetooth speaker"
  ],
  "sortBy": "best_match",
  "maxPages": 1,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

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

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

## `runSummary` (type: `string`):

RUN_SUMMARY record (pushed, skipped, emptyReason)

# 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": [
        "bluetooth speaker"
    ],
    "sortBy": "best_match",
    "maxPages": 1,
    "maxItems": 20,
    "mode": "scrape"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/alibaba-products").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": ["bluetooth speaker"],
    "sortBy": "best_match",
    "maxPages": 1,
    "maxItems": 20,
    "mode": "scrape",
}

# Run the Actor and wait for it to finish
run = client.actor("datahamster/alibaba-products").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": [
    "bluetooth speaker"
  ],
  "sortBy": "best_match",
  "maxPages": 1,
  "maxItems": 20,
  "mode": "scrape"
}' |
apify call datahamster/alibaba-products --silent --output-dataset

```

## MCP server setup

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

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/SsnebNIr1Edb7KjAx/builds/5K55W9MeGAMcF8lMu/openapi.json