# Alibaba Listings Scraper — Suppliers, MOQ & Price (`khadinakbar/alibaba-listings-scraper`) Actor

Search Alibaba.com B2B listings by keyword or URL: title, price range, MOQ, supplier name, country, years, verified / gold / trade-assurance flags, rating, image. Filters for price, MOQ, supplier country/years, verified-only, trade-assurance-only. PPE. MCP-ready.

- **URL**: https://apify.com/khadinakbar/alibaba-listings-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 2 total users, 1 monthly users, 46.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 alibaba 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 Listings Scraper

Alibaba Listings Scraper is an Apify Actor for searching Alibaba.com B2B listings by keyword or Alibaba search/category URL. It returns one record per product card, which means each dataset item represents a listing shown in search results rather than a single product-detail page. The output includes title, price range, MOQ, supplier name, supplier country, years on Alibaba, Verified / Gold Supplier / Trade Assurance flags, rating, image, product URL, and related supplier signals when available. It is usable through Apify MCP and through the Apify platform UI and API.

### Best fit and connected workflows

This Actor fits workflows that start with Alibaba search results and end with structured supplier research.

Use it when you want to:

- collect B2B product cards for sourcing analysis,
- compare supplier indicators such as country, years on Alibaba, and verification flags,
- build lists for procurement review or marketplace monitoring,
- feed a downstream enrichment step with Alibaba product URLs and supplier details.

Use A practical next-step pairing is [Alibaba Products Scraper - Suppliers, Prices & MOQ](https://apify.com/khadinakbar/alibaba-products-scraper) when your workflow moves from search-result discovery to a more focused product and supplier contract.

### Example scenario

Mina, a sourcing manager, starts with the keyword `stainless steel water bottle` and wants a shortlist of listings for review. She runs the Actor with `maxResults`, `verifiedOnly`, and `tradeAssuranceOnly` enabled, then reviews returned fields such as `priceMin`, `minOrderQuantity`, `supplierName`, `supplierCountry`, `supplierYearsOnAlibaba`, and `rating`. She uses those records to decide which suppliers deserve a manual quote request, then opens the product URLs for the selected listings.

### Input

| Field | Type | What it controls |
|---|---|---|
| `searchQuery` | string | Keyword search for Alibaba B2B product listings. |
| `startUrls` | array | Alibaba search or category URLs to scrape directly. |
| `maxResults` | integer | Maximum number of product records to return. |
| `sortBy` | string | Result order: relevance, transactionDesc, responseRate, priceAsc, priceDesc, or newest. |
| `minPrice` | integer | Lower bound for unit price in USD. |
| `maxPrice` | integer | Upper bound for unit price in USD. |
| `minMoq` | integer | MOQ lower bound passed to Alibaba search. |
| `maxMoq` | integer | MOQ upper bound applied after extraction. |
| `verifiedOnly` | boolean | Keeps Verified or Gold Supplier listings. |
| `tradeAssuranceOnly` | boolean | Keeps listings with Trade Assurance. |
| `minSupplierYears` | integer | Supplier age floor on Alibaba. |
| `supplierCountries` | array | ISO-2 supplier country whitelist. |
| `minRating` | integer | Supplier rating floor from 0 to 5. |
| `minOrders` | integer | Minimum recorded orders or transactions. |
| `site` | string | Alibaba domain, currently `www.alibaba.com`. |
| `proxyConfiguration` | object | Proxy settings, with Apify proxy enabled by default. |

#### Valid input example

```json
{
  "searchQuery": "wireless earbuds",
  "maxResults": 25,
  "sortBy": "transactionDesc",
  "verifiedOnly": true,
  "tradeAssuranceOnly": true,
  "minSupplierYears": 3,
  "supplierCountries": ["CN"],
  "minRating": 4,
  "minOrders": 50
}
```

### Output

One dataset record represents one Alibaba product listing card.

| Field | Type | Meaning |
|---|---|---|
| `recordType` | string | Always `product`. |
| `productId` | string | Alibaba product identifier. |
| `title` | string | Listing title. |
| `productUrl` | string | Product URL. |
| `imageUrl` | string | Listing image URL. |
| `priceMin` | number | Lower value from the displayed price range. |
| `priceMax` | number | Upper value from the displayed price range. |
| `currency` | string | Price currency. |
| `minOrderQuantity` | integer | MOQ value. |
| `moqUnit` | string | MOQ unit such as piece. |
| `supplierName` | string | Supplier name. |
| `supplierId` | string | Supplier identifier. |
| `supplierUrl` | string | Supplier storefront URL. |
| `supplierCountry` | string | Supplier country code or value. |
| `supplierCountryInferred` | boolean | Indicates inferred supplier country. |
| `supplierYearsOnAlibaba` | integer | Years the supplier has been on Alibaba. |
| `isVerifiedSupplier` | boolean | Verified supplier flag. |
| `isGoldSupplier` | boolean | Gold Supplier flag. |
| `isTradeAssurance` | boolean | Trade Assurance flag. |
| `responseRatePercent` | number | Supplier response rate. |
| `rating` | number | Supplier rating. |
| `reviewsCount` | integer | Review count. |
| `ordersCount` | integer | Recorded orders or transactions. |
| `position` | integer | Listing position in results. |
| `searchQuery` | string | Original query used for the run. |
| `site` | string | Alibaba domain used. |
| `scrapedAt` | string | Timestamp for the record. |
| `_warnings` | array | Optional extraction notes. |

#### Illustrative output record

```json
{
  "recordType": "product",
  "productId": "1600123456789",
  "title": "Bluetooth 5.3 Wireless Earbuds TWS",
  "productUrl": "https://www.alibaba.com/product-detail/example_1600123456789.html",
  "imageUrl": "https://s.alicdn.com/example.jpg",
  "priceMin": 2.5,
  "priceMax": 4.8,
  "currency": "USD",
  "minOrderQuantity": 10,
  "moqUnit": "piece",
  "supplierName": "Shenzhen Audio Tech Co., Ltd.",
  "supplierId": "220123456789",
  "supplierUrl": "https://shenzhen-audio.en.alibaba.com",
  "supplierCountry": "CN",
  "supplierCountryInferred": true,
  "supplierYearsOnAlibaba": 7,
  "isVerifiedSupplier": true,
  "isGoldSupplier": true,
  "isTradeAssurance": true,
  "responseRatePercent": 98.5,
  "rating": 4.8,
  "reviewsCount": 342,
  "ordersCount": 1250,
  "position": 1,
  "searchQuery": "wireless earbuds",
  "site": "www.alibaba.com",
  "scrapedAt": "2026-06-20T17:30:00.000Z"
}
```

### How it works

The Actor opens Alibaba search-result pages from a keyword or from supplied search/category URLs, then collects product listing cards across pages until `maxResults` is reached. The live contract specifies a PlaywrightCrawler implementation with Chromium, embedded JSON first parsing, DOM fallback, session pool, and fingerprints. It also auto-paginates through result pages and respects the result cap as the cost ceiling. The proxy setup prefers Apify residential proxy when available and falls back to Apify datacenter proxy through the default configuration.

### Pricing

This Actor uses Pay per event plus Apify platform usage. The live contract charges one event for Actor start and one event for each Alibaba product scraped into the dataset. Filtered-out products are not billed.

Example: a run that returns one hundred product records charges one start event plus one hundred product events. For current billing details, open the live Pricing tab on the Apify Actor page.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a tool for Alibaba listing discovery and supplier signal extraction.

Tool description: retrieve Alibaba B2B search-result listings by keyword or Alibaba search/category URL and return structured product cards with pricing, MOQ, supplier, verification, and rating fields.

Exact Actor identity: `khadinakbar/alibaba-listings-scraper`

> Find Alibaba B2B listings for "wireless earbuds", keep Verified or Gold Suppliers with Trade Assurance, and return the first 25 product cards with price range, MOQ, supplier country, years on Alibaba, rating, and product URLs.

Output interpretation:

- Each dataset record is one product card from Alibaba search results.
- `productId` identifies the listing.
- `supplierName`, `supplierCountry`, `supplierYearsOnAlibaba`, `isVerifiedSupplier`, `isGoldSupplier`, and `isTradeAssurance` support supplier screening.
- `priceMin` and `priceMax` reflect the listing's displayed unit price range.
- `position` shows the listing order in the source results.
- `scrapedAt` supports freshness checks in agent workflows.

Provenance and scope:

- Source pages are Alibaba search or category pages.
- Product-detail URLs and non-Alibaba URLs are outside the search contract for this Actor.
- The output is a dataset that can be read through the Apify API and reused in downstream agent steps.

Pagination and cost guidance:

- `maxResults` sets the upper bound for returned product cards.
- The Actor auto-paginates until that cap is met.
- Each returned product card is a billable event, so the cap also works as a budget control.

### Apify API example

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

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

const run = await client.actor('khadinakbar/alibaba-listings-scraper').call({
  searchQuery: 'wireless earbuds',
  maxResults: 10,
  verifiedOnly: true,
  tradeAssuranceOnly: true,
});

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

console.log(items);
```

Set `APIFY_TOKEN` in your environment before running the example. The dataset readback returns the product records collected by the Actor.

### Best results and outcome guidance

Use a keyword when you want broad discovery. Use `startUrls` when you already have a curated Alibaba search or category page. Pair `verifiedOnly`, `tradeAssuranceOnly`, `minSupplierYears`, `supplierCountries`, `minRating`, and `minOrders` when your review process benefits from supplier signals as part of the first pass. Keep `maxResults` aligned with the number of records you want to review downstream. If the search task is country-specific, set `supplierCountries` with ISO-2 codes such as `CN` or `VN`.

### Design note

I found that the output schema requires `recordType`, `productId`, and `scrapedAt`, which makes each dataset row easy to treat as a timestamped product event.

### FAQ

#### Can I use a keyword and a search URL together?

Yes. The input schema accepts both `searchQuery` and `startUrls`, and both can be used to shape discovery.

#### What kind of pages work with `startUrls`?

Alibaba search and category pages fit the input contract. Product-detail URLs sit outside the listing-scrape workflow for this Actor.

#### What fields help with supplier screening?

`supplierCountry`, `supplierYearsOnAlibaba`, `isVerifiedSupplier`, `isGoldSupplier`, `isTradeAssurance`, `rating`, `reviewsCount`, and `ordersCount` are the key supplier-facing fields in the dataset.

#### How does `maxResults` relate to cost?

The Actor stops at the `maxResults` cap, and each returned product card counts as one billable event.

#### Is this Actor usable through MCP?

Yes. It is MCP-ready and exposed as `khadinakbar/alibaba-listings-scraper` for agent workflows.

### Responsible use

Use Alibaba Listings Scraper for compliant sourcing, catalog analysis, and supplier research on publicly accessible search-result pages. Follow Alibaba's terms, local laws, and your organization's data handling rules when storing or reusing results.

# Actor input Schema

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

Free-text keyword to search Alibaba B2B products (e.g. 'wireless earbuds'). The Actor opens the Alibaba search-results page and collects every product listing card across pages. Leave empty if you instead provide startUrls. NOT a single product URL — this Actor searches and returns many products, it does not scrape one product-detail page.

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

Optional list of Alibaba search or category URLs to scrape directly (e.g. https://www.alibaba.com/trade/search?SearchText=led+strip or a /catalog/ URL). Use this instead of, or together with, searchQuery. Product-detail URLs (/product-detail/...) and non-Alibaba URLs are ignored — this Actor only scrapes search/category result pages.

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

Maximum number of product records to return. The Actor auto-paginates until this cap is reached, then stops, so it doubles as your cost ceiling (each product is one billable event). Defaults to 100. Set higher for bulk sourcing research.

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

Order in which Alibaba returns the search results. 'relevance' is Alibaba Best Match (default); 'transactionDesc' surfaces high-transaction suppliers; 'responseRate' surfaces fast-responding suppliers; 'priceAsc'/'priceDesc' sort by price; 'newest' shows recently listed items. Applies to keyword searches; for startUrls the URL's own sort is respected.

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

Only return products whose unit price (minimum of the price range) is at or above this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no minimum.

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

Only return products whose unit price (maximum of the price range) is at or below this value in USD. Applied as an Alibaba URL filter and as a safety re-check on the parsed price. Leave empty for no maximum.

## `minMoq` (type: `integer`):

Server-side MOQ floor passed to Alibaba's search URL. Combine with maxMoq to bracket a target MOQ window. Leave empty for no MOQ lower bound.

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

Drop products whose minimum order quantity (MOQ) is above this value (e.g. 100 keeps only products requiring up to 100 pieces minimum). Useful for small-volume sourcing. Applied client-side after extraction; products with unknown MOQ are dropped when this bound is set. Leave empty for no upper bound.

## `verifiedOnly` (type: `boolean`):

When enabled, keep only products from Verified or Gold Suppliers (Alibaba's supplier vetting tiers). Filtered products are not billed. Default false.

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

When enabled, keep only products offering Alibaba Trade Assurance (escrow + dispute protection). Filtered products are not billed. Default false.

## `minSupplierYears` (type: `integer`):

Drop products from suppliers with fewer than this many years on Alibaba (e.g. 3 keeps suppliers with 3+ years). Useful to skip brand-new sellers. Products with unknown years are dropped when this bound is set. Filtered products are not billed. Leave empty to keep all.

## `supplierCountries` (type: `array`):

Optional whitelist of supplier countries as ISO-3166 alpha-2 codes (e.g. \['CN','VN','IN','PK']). Only products whose supplier is based in one of these countries are kept. Products with unknown supplier country are dropped when this filter is set. Leave empty to allow all countries.

## `minRating` (type: `integer`):

Drop products whose supplier average rating (0–5) is below this value, or whose rating is unknown. Useful to keep only well-reviewed suppliers. Filtered products are not billed. Leave empty to keep all ratings.

## `minOrders` (type: `integer`):

Drop products with fewer than this many recorded orders/transactions, or with unknown order count. Useful to surface proven listings. Filtered products are not billed. Leave empty to keep all.

## `site` (type: `string`):

Which Alibaba domain to search. Defaults to the global English site 'www.alibaba.com'.

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

Proxy settings. Residential proxies are strongly recommended — Alibaba blocks most datacenter IPs. The Actor automatically prefers Apify residential when your account has it, and gracefully falls back to Apify datacenter when it does not — so leaving this at the default works on any plan. Override only for a specific proxy requirement.

## Actor input object example

```json
{
  "searchQuery": "stainless steel water bottle",
  "startUrls": [],
  "maxResults": 10,
  "sortBy": "relevance",
  "verifiedOnly": false,
  "tradeAssuranceOnly": false,
  "supplierCountries": [],
  "site": "www.alibaba.com",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All product listing records found across the search/category 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": "wireless earbuds",
    "startUrls": [],
    "maxResults": 10,
    "supplierCountries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/alibaba-listings-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": "wireless earbuds",
    "startUrls": [],
    "maxResults": 10,
    "supplierCountries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/alibaba-listings-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": "wireless earbuds",
  "startUrls": [],
  "maxResults": 10,
  "supplierCountries": []
}' |
apify call khadinakbar/alibaba-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/15WbTOWces7c1L664/builds/ZsuJ4SWpvvMjSTzd6/openapi.json