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

Scrape Alibaba product listings and supplier profiles by keyword or product URL. Export prices, MOQs, images, price tiers, specifications, variants, certifications, and supplier performance.

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

## Pricing

$1.19 / 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

Scrape Alibaba product listings and the supplier facts shown with them, then export Alibaba data to CSV, JSON, or Excel. This Alibaba API alternative searches public products by keyword, accepts direct product URLs, and returns prices, minimum order quantities, images, specifications, variants, certifications, and supplier performance in a consistent dataset.

Use product mode to compare individual offers or supplier mode to build a deduplicated list of companies represented in product search. Product detail enrichment is enabled by default, so a listing can include its quantity price tiers and specifications as well as the supplier behind it. Each row records the search term that found it, which helps when several searches are combined in one run.

### What data can you extract from Alibaba?

The dataset uses one row per product in `products` mode and one row per discovered supplier in `suppliers` mode. Product rows are flat at the top level. Lists and named attributes stay inside the row so that each product remains a single record. A field appears when the public page publishes it; empty or unpublished facts are left empty.

| Field | Description | Example |
| --- | --- | --- |
| `recordType` | Whether the row describes a product or supplier | `product` |
| `keyword` | Search term that found the row | `insulated water bottle` |
| `productId` | Marketplace product identifier | `1600981611818` |
| `title` | Product listing title | `High Quality Custom Logo 500ml...` |
| `url` | Direct product link | `https://www.alibaba.com/product-detail/...html` |
| `price` | Displayed unit price or range | `$1.76-2.13` |
| `currency` | Recognized price currency | `USD` |
| `moq` | Minimum order text | `Min. order: 100 pieces` |
| `moqQuantity` | Minimum order as a number | `100` |
| `imageUrl` | Primary product image | image URL |
| `images` | Product image gallery | array of image URLs |
| `productScore` | Search card product score | `4.8` |
| `reviewScore` | Search card review score | `4.8` |
| `reviewCount` | Search card review count | `61` |
| `shippingScore` | Search card shipping score | `4.8` |
| `soldCount` | Displayed sold quantity | `15461` |
| `badges` | Listing badge records | array |
| `certifications` | Search card certification labels | array |
| `priceTiers` | Quantity ranges and unit prices | array of tier records |
| `specifications` | Named product properties | `{"Material":"Stainless Steel"}` |
| `variants` | Option groups and available choices | color and capacity groups |
| `description` | Published product description text | text |
| `descriptionImages` | Images in the structured description | array of URLs |
| `productCertifications` | Detailed published certification records | array |
| `sampleAvailable` | Whether a sample can be ordered | `true` |
| `samplePrice` | Published sample unit price | `2.13` |
| `productReviewScore` | Product page review score | `4.8` |
| `productReviewCount` | Product page review count | `61` |
| `categoryPath` | Product breadcrumb labels | array |
| `salesVolume` | Published product sales quantity | `15461` |
| `supplierId` | Supplier company identifier | `230538595` |
| `supplierName` | Supplier company name | company name |
| `supplierCountry` | Supplier country code | `CN` |
| `supplierUrl` | Public supplier profile link | profile URL |
| `supplierHomeUrl` | Supplier storefront link | storefront URL |
| `supplierLogoUrl` | Supplier logo image | image URL |
| `supplierYears` | Years on the marketplace | `11` |
| `supplierStarLevel` | Search card supplier level | `4` |
| `supplierServiceScore` | Search card service score | `4.7` |
| `supplierBusinessType` | Published business type | `Manufacturer,Trading Company` |
| `supplierEmployees` | Published employee range | `101-200` |
| `supplierResponseTime` | Published response time | `≤2h` |
| `supplierOnTimeDeliveryRate` | Published delivery rate | `98.9%` |
| `supplierReviewScore` | Supplier review score | `4.8` |
| `supplierReviewCount` | Supplier review count | number |
| `supplierSixMonthOrders` | Orders in the reported six month period | `280` |
| `supplierSixMonthOrderValue` | Order value in that period | `659244.56` |
| `supplierExportMarkets` | Main export markets shown on the page | array of countries |
| `verifiedManufacturer` | Published manufacturer verification flag | `true` |
| `tradeAssurance` | Published order protection flag | `true` |
| `isAd` | Whether the search listing is sponsored | `true` |
| `sampleProductId` | Product used to find a supplier row | product ID |
| `sampleProductUrl` | Link to that sample product | product URL |

Supplier mode returns the supplier fields, `recordType`, `keyword`, and a sample product reference. It does not imply a complete directory of every supplier matching a term. Its discovery path is public product search, followed by supplier details attached to those products.

### How to scrape Alibaba

1. Enter one or more product search terms in `keywords`, or paste direct product links into `productUrls`.
2. Choose `products` for offer comparison or `suppliers` for unique suppliers found through those offers. Set `maxResults` for each search term and `maxItems` for the whole run.
3. Keep `includeDetails` enabled when price tiers, variants, specifications, certifications, and supplier performance matter. Turn it off for a faster listing-only product export.
4. Run the actor and open its dataset. Download JSON, CSV, or Excel, or read the results through the dataset endpoint.

The first page of a broad search often contains enough listings for a small job. For larger jobs, the actor follows public search pagination, removes duplicate product identifiers, and stops at the requested number of accepted rows. A request with several terms searches them in the order supplied.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `keywords` | string array | empty | Product searches, each handled separately. |
| `productUrls` | string array | empty | Direct public product pages; can be used without keywords. |
| `resultType` | string | `products` | `products` or `suppliers`. |
| `maxResults` | integer | `100` | Maximum accepted rows for each keyword. |
| `maxItems` | integer | `0` | Total dataset cap; zero means no additional cap. |
| `includeDetails` | boolean | `true` | Enrich product cards with their detail pages. Supplier mode always enriches. |
| `minPrice` | number | unset | Minimum lowest listed unit price. |
| `maxPrice` | number | unset | Maximum lowest listed unit price. |
| `maxMOQ` | integer | unset | Maximum minimum order quantity. |
| `supplierCountries` | string array | empty | Supplier country codes to keep. |
| `verifiedManufacturer` | boolean | `false` | Keep only suppliers marked as verified manufacturers in detail data. |
| `tradeAssuranceOnly` | boolean | `false` | Keep only suppliers whose detail data indicates order protection. |
| `proxyConfiguration` | object | proxy enabled | Connection settings for public pages. |

At least one keyword or product URL is required. `maxResults` counts accepted rows, so a filter may make the actor inspect more listings before it reaches the requested count. The price filters use the lowest published unit price, usually the largest quantity tier. Currency follows the public page; this input does not force a destination market or currency.

A realistic product search:

```json
{
  "keywords": ["insulated water bottle"],
  "resultType": "products",
  "maxResults": 35,
  "includeDetails": true,
  "supplierCountries": ["CN"]
}
```

For a focused supplier list, set `resultType` to `suppliers` and choose a product term such as `stainless steel water bottle`. The result is one row per supplier encountered in public product listings. A direct URL input is useful when a buyer already has a shortlist and wants comparable specifications and pricing without searching again.

### Output example

This shortened item comes from a successful 35-result run for `insulated water bottle`. Long image lists, certifications, and the supplier name are omitted from the display example; they remain in the actual dataset.

```json
{
  "recordType": "product",
  "keyword": "insulated water bottle",
  "productId": "1600981611818",
  "title": "High Quality Custom Logo 500ml Temperature Smart Water Bottles Insulated Smart Water Bottle With Led Temperature Display",
  "url": "https://www.alibaba.com/product-detail/High-Quality-Custom-Logo-500ml-Temperature_1600981611818.html",
  "price": "$1.76-2.13",
  "currency": "USD",
  "moq": "Min. order: 100 pieces",
  "moqQuantity": 100,
  "reviewScore": 4.8,
  "reviewCount": 61,
  "soldCount": 15461,
  "priceTiers": [
    {"min": 100, "max": 499, "price": 2.13},
    {"min": 500, "max": 4999, "price": 1.96}
  ],
  "specifications": {
    "drinkware type": "Vacuum Flasks & Thermoses",
    "Capacity": "500ml"
  },
  "supplierId": "230538595",
  "supplierCountry": "CN",
  "supplierYears": 11,
  "supplierBusinessType": "Manufacturer,Trading Company",
  "supplierOnTimeDeliveryRate": "98.9%",
  "tradeAssurance": true,
  "isAd": true
}
```

The example includes a sponsored listing because the search page displayed one. Use `isAd` to separate sponsored and other listings in your analysis. A product may have a price range on the search card and several more precise prices by quantity in `priceTiers`; use the latter when calculating order costs. A supplier's service statistics are public page values and may change after the run.

### Use cases

- **Sourcing teams:** compare minimum orders, quantity prices, supplier type, and response time before requesting quotations.
- **Retail buyers:** find products that fit a budget and order size, then inspect variant choices and sample availability.
- **Market researchers:** track public listing prices, sold quantities, review signals, and category paths for a product niche.
- **Quality teams:** collect published product attributes and certification records for a shortlist that needs manual review.
- **Supplier analysts:** build a unique list of suppliers encountered in a product search, with country and public performance figures.
- **Catalog teams:** gather titles, images, descriptions, and attributes for internal comparison sheets. Review each listing before reuse or publication.

These workflows benefit from keeping the source URL beside every row. The dataset is a snapshot of public information, not a live stock or binding quotation feed. A buyer should confirm current price, availability, shipping, and certification directly before placing an order.

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

The current result price is **$1.192 per 1,000 dataset items**, or **$0.001192 per result**. Charges follow delivered rows, so a run that finds fewer accepted rows costs less than its requested limit. Platform usage is included in this result price. Price filters can require more page visits, but they do not create extra result charges for rejected listings.

| Delivered results | Result charge |
| ---: | ---: |
| 100 | $0.1192 |
| 1,000 | $1.192 |
| 5,000 | $5.96 |

A 35-row product run produced 35 dataset items in a successful test. Its result charge at this rate is $0.04172. The public search pages may stop before a requested 5,000 results for one broad term; that price example describes the charge only if 5,000 rows are actually delivered across searches. Set `maxItems` to keep a firm total output cap.

### Tips for best results

Search with concrete product names, materials, sizes, or uses. `insulated water bottle` is broader than `500ml stainless steel smart water bottle`, so it returns a wider mix of offers. Use several specific terms when a single search reaches the site's pagination boundary. Product IDs are deduplicated across the run, which avoids counting the same offer twice when search terms overlap.

Keep detail enrichment on when comparing wholesale prices. The search card's price text is a quick summary, whereas `priceTiers` records quantity ranges from the product page. An empty tier array can mean the product uses another pricing presentation or the page did not publish tiers. Read `moqQuantity` together with `moq` because units such as pieces, sets, or meters matter.

Use `supplierCountries`, `maxMOQ`, and price filters to narrow output, but allow a larger `maxResults` when the filter is strict. Filters are applied to the retrieved public data. They do not change the site's own ranking or guarantee that every matching listing on the marketplace has been searched. Supplier mode needs enough product listings to encounter a useful number of unique companies.

For a repeatable comparison, save the input and run it on a schedule. Keep the keyword, product URL, and collection date with exported files. Listings can change title, price, certification display, and supplier scores without warning, and search ranking can move between runs.

### Limits

Public search pagination reported up to 100 pages for the tested broad keyword, with roughly 48 listing cards per page. Other terms can have different totals, and later pages may repeat products or expose fewer unique results. The actor stops when a page adds no new product IDs or the public page limit is reached. The `10000` input maximum is a safety ceiling, not a promise that one term can return that many unique rows.

The tested supplier profile URL showed an access page, so supplier rows are built from public product listings and supplier information attached to product pages. Supplier mode is therefore a list of suppliers found through products, not a complete directory search. There is no verification-report or store-review collection in this version. Product certifications are the records shown with individual products; their presence should be checked against the source document when compliance decisions matter.

Some product pages omit price tiers or full descriptions. In the 35-row test, all 35 had product IDs, titles, URLs, supplier names, specifications, and supplier business types; 26 had price tiers. Published supplier facts, scores, sample details, and descriptions vary by listing. An access page can also temporarily prevent enrichment. In that case, search-card fields may still be present, while detail-only fields are empty. The actor tries the public showroom page when search data is unavailable.

The displayed currency and delivery context reflect the public page returned during collection. This actor does not offer destination-country localization, custom marketplace sorting, category browsing, supplier verification reports, or review collection. It does not sign in or request private account data.

### API use

A program can start a run with the same JSON input shown above and read the default dataset after it finishes. Each row has stable top-level keys for product and supplier facts, so consumers can map them into a purchasing sheet or database. Use `recordType` when combining product and supplier runs, and use `productId` or `supplierId` as a deduplication key.

Two practical requests are: “Collect 100 stainless steel bottle products and keep suppliers in CN with an MOQ of at most 500,” and “Find unique suppliers represented in solar panel product search and return their public response times and delivery rates.” Both map directly to the documented inputs; the second request uses `resultType: "suppliers"`.

### FAQ

**Is scraping this data legal?** This actor reads public product and company listing information. Check the site's terms and the rules that apply to your use, respect privacy and intellectual property, and do not misuse personal data. A public listing is not a license to republish its images or descriptions without review.

**Do I need to configure a proxy?** The default input enables the platform proxy. The actor starts with datacenter access and can escalate when requests are blocked. Access conditions can change, so an occasional missing detail field does not necessarily mean a listing was removed.

**How fast is it?** A measured run returned 35 enriched products in about one minute. Runtime depends on the number of detail pages, network conditions, blocks, and how many search pages must be scanned for accepted results. Listing-only mode is generally faster because it skips product detail requests.

**Can I schedule and monitor runs?** Yes. Save the input, schedule the actor, and inspect the run status and dataset item count. Compare counts and filled fields over time if a recurring feed is important to your workflow.

**Can I export to a spreadsheet?** Yes. Download the dataset as CSV or Excel, or use its JSON endpoint in an existing data workflow. Nested arrays such as `priceTiers` and `variants` are most convenient in JSON; a spreadsheet may need separate columns or a follow-up transform.

**Why is a field empty?** Public listings differ. Some sellers do not publish a value, some fields are only on detail pages, and an access page can interrupt enrichment. Check `includeDetails`, open the `url`, and compare the public product page if a specific field is essential.

**Does supplier mode search every factory?** No. It returns unique suppliers found through public product search for the supplied keyword. Search with several relevant products to broaden discovery, and use the sample product link to understand why each supplier appeared.

### Integrations

Read results through the dataset API, export files, or connect completed runs to webhooks, scheduling, and workflow services. A purchasing dashboard can join rows by product or supplier ID; a spreadsheet can refresh from scheduled exports. Keep the original product URL in downstream records for manual checks, and record when each snapshot was collected.

### Support

Open an issue on the Issues tab; we reply within 24h and add fields on request. Include a public product URL, the input used, and the field you expected so the listing can be checked against the current page.

# Actor input Schema

## `keywords` (type: `array`):

Search terms. Each term is searched separately; maxResults applies to each.

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

Optional direct product-detail URLs. These can be used without keywords.

## `resultType` (type: `string`):

Return product rows or one supplier row per supplier found in product search.

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

Maximum unique products or suppliers for each keyword.

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

Hard limit across all keywords and direct URLs. Set 0 for no total cap.

## `includeDetails` (type: `boolean`):

Fetch each product page for price tiers, variants, specifications, certifications, and full supplier data. Supplier mode always fetches details.

## `minPrice` (type: `number`):

Keep products whose lowest listed unit price is at least this amount in the displayed currency.

## `maxPrice` (type: `number`):

Keep products whose lowest listed unit price is no more than this amount in the displayed currency.

## `maxMOQ` (type: `integer`):

Keep listings with a minimum order quantity no greater than this.

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

Optional supplier country codes such as CN or IN.

## `verifiedManufacturer` (type: `boolean`):

Keep products whose detail page marks the supplier as a verified manufacturer.

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

Keep listings whose supplier detail shows Trade Assurance service.

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

Proxy settings for public pages; datacenter addresses are tried first.

## Actor input object example

```json
{
  "keywords": [
    "insulated water bottle"
  ],
  "productUrls": [],
  "resultType": "products",
  "maxResults": 100,
  "maxItems": 0,
  "includeDetails": true,
  "supplierCountries": [],
  "verifiedManufacturer": false,
  "tradeAssuranceOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All product or supplier rows in the default dataset.

# 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 = {
    "keywords": [
        "insulated water bottle"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/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 = {
    "keywords": ["insulated water bottle"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/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 '{
  "keywords": [
    "insulated water bottle"
  ],
  "maxResults": 100
}' |
apify call mlg14/alibaba-scraper --silent --output-dataset

```

## MCP server setup

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