# Alibaba Products Scraper: Wholesale Suppliers, Prices & MOQ (`hyperbach/alibaba-scraper`) Actor

Scrape Alibaba.com products and suppliers by keyword, search URL, product URL, storefront or image: wholesale price range and tiers, MOQ, SKUs, specs, certifications, and the supplier's name, country, years, verified badges and rating. Supplier search and product details too. Misses free.

- **URL**: https://apify.com/hyperbach/alibaba-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 products

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 Products Scraper: Wholesale Prices, MOQ & Suppliers

**Alibaba.com products and suppliers, logged out: search words, search URLs with their filters, categories, product URLs or ids, supplier storefronts, images and supplier searches in; one row per product out — the id and URL, title, price or price range in your currency, the minimum order, images, certifications, the sold count, the ad flag, and the supplier's name, id, country, years on Alibaba, store URL, verification badges and rating — and with the product page on, the price ladder, every SKU with its price and stock, the specs, the description, the certificate documents, lead times, samples and the supplier's profile.** One free `search` row per input says what it gave: COMPLETE, CAPPED, TRUNCATED (Alibaba's own depth limit, with its count) or PARTIAL. 71 ship-to countries in 52 currencies, every page checked to be in the view you asked. No login, no API key, no browser, proxies handled for you.

**From $5.00 per 1,000 rows (`product`) on the Free plan, $4.25 on Starter; every row and add-on is priced under Pricing below.** A run start is $0.005. The default input returns about 50 rows for about $0.255. Every input gets one free `search` row with its verdict; a product Alibaba does not have (`not_found`), a search it lists nothing for on four fresh tries (`no_results`) and a refusal the run could not pass (`failed`) are named there and never charged.

![An Alibaba product page in a browser window: a desk lamp with price tiers, a minimum order and a sample price. Beside it, the row this Actor returns, with price_range_usd and sample_price highlighted, plus the minimum order, orders and the supplier's years, rating and verification.](https://api.apify.com/v2/key-value-stores/dcLLNGq99686o2A4v/records/hero-alibaba-scraper.webp)

### Tested head-to-head on 2026-11-04

The job: the products of one Alibaba search (led lights, the schema's example query), 50 products. Every Actor ran on it the same day from the same harness; a rival's cost is what a buyer account paid, this Actor's is its list price on the Free plan. Fields counts the filled fields of a typical row. Re-measured monthly.

| Actor | Rows | First row | Run time | Cost | Fields | Failures |
|---|---|---|---|---|---|---|
| **this Actor** | 50 | 4.6 s | 23 s | $0.26 | 43 | none |
| `zen-studio/alibaba-scraper` | 50 | 13 s | 54 s | $0.24 | 6 | none |
| `devcake/alibaba-products-scraper` | 60 | 28 s | 30 s | $0.067 | 26 | none |

### Why this Alibaba scraper

- **Every input Alibaba has.** Search words (`led strip light`), search URLs from your browser with their filters, category pages, `/products/` and `/showroom/` pages, product URLs or ids, a supplier's storefront (its whole catalogue), an image (search by image: an Alibaba CDN image directly, any other image uploaded for you) and supplier searches (the Suppliers tab, one row per supplier). Each input gets its own cap (`maxItemsPerQuery`), the run's cap sits on top (`maxItems`).
- **The product page on every row, when you want it.** `includeDetails` reads each product's page: the price ladder by quantity (in your currency and in USD), every SKU with its values, price and stock, the specs (5–82 attributes a page over 864 rows of our test runs, 2026-11-04), the seller's description (the page's blocks or its HTML), the certificate documents with number and validity, lead times, samples, customization, trade terms, places of dispatch, the category path and the supplier's profile: business type, staff, floorspace, online revenue, on-time rate, response time, 6-month orders. On five ordinary searches of 10 products each (2026-11-04) 50 of 50 rows got their page, 46 a text description and 4 an image-only one, in 23.5 s.
- **The view you ask, checked.** 71 ship-to countries, each read by Alibaba's own Deliver-to setting, in any of 52 currencies (measured on every country, 2026-11-04). Every search page and product page is checked to be in that country and currency: a page Alibaba serves in another view is read again on a fresh exit, never delivered. The run's exits are in the view's country where the proxy has them.
- **Alibaba's own filters.** Price range, maximum MOQ, supplier countries, Verified Supplier, Verified Pro, Guaranteed, product and company certifications, minimum store rating, delivery within 18 / 24 / 30 days, local stock (the view's own value, read from Alibaba's page), plus `excludeIds` and `skipAds`, which skip before a row is counted or charged.
- **Honest runs.** Every refusal (Alibaba's slider, an empty list, another view) is retried on a fresh exit at once; a search is `no_results` only when four fresh exits agree, a product `not_found` only when two do. Every input gets a row that says what happened; a product is charged once a run, a product page only when it was read.

### Who it's for

- **Importers and sourcing teams** — a shortlist of suppliers for a product: the price ladder by quantity, minimum orders, lead times, samples, certificates and the supplier's verification, staff, revenue and on-time rate, side by side for every search.
- **E-commerce and dropshipping sellers** — the prices, SKUs and stock of a product category or of one supplier's whole storefront, in your own country's view and currency, read again on a schedule to see what moved.
- **Researchers and data teams** — typed rows keyed by `product_id` and `supplier_id`, a free row per input with the verdict, and a run summary to check a pipeline against.

### Quick start

**The first 100 products of a search**

```json
{
  "searchQueries": [
    "led lights"
  ],
  "maxItemsPerQuery": 100
}
```

**50 products with their product pages**

```json
{
  "searchQueries": [
    "insulated water bottle"
  ],
  "maxItemsPerQuery": 50,
  "includeDetails": true
}
```

**Product URLs or ids**

```json
{
  "productUrls": [
    "1600318274427"
  ]
}
```

**Verified suppliers' products in Germany, in euros**

```json
{
  "searchQueries": [
    "stainless steel tumbler"
  ],
  "shipToCountry": "DE",
  "currency": "EUR",
  "verifiedSupplier": true,
  "maxItemsPerQuery": 50
}
```

**Suppliers with their report**

```json
{
  "supplierQueries": [
    "insulated water bottle"
  ],
  "includeSupplierReport": true,
  "maxItemsPerQuery": 20
}
```

### Switching from `zen-studio/alibaba-scraper`?

Your input works as it is. Each name in the left column is read as this Actor's own field and the run log says so (`read <theirs> as <ours>`); a name marked *not read* is ignored with a note. A value in the other Actor's shape, an object list or its own date form, is read too.

| zen-studio/alibaba-scraper | this Actor | what to know |
|---|---|---|
| `resultType` | *not read* | `products` (the default) is the search; `suppliers` reads the keywords as `supplierQueries`; `category` reads the `category` name as search words. |
| `keywords` | `searchQueries` | Each keyword is one search, as on the leader. |
| `category` | *not read* | The leader's category name is read as the search of that name; give a category URL (`https://www.alibaba.com/catalog/…_cid…`) in `startUrls` to read the category itself. |
| `maxResults` | `maxItemsPerQuery` | Per input (per keyword); 0 here means no cap. |
| `marketplace` | *not read* | `worldwide` is not served logged out (the Worldwide tab is rendered in the browser): the standard marketplace is read and the run says so. |
| `shipToCountry` | `shipToCountry` | The same 71 countries; `currency` picks the currency apart from the country. |
| `includeSupplierReport` | `includeSupplierReport` | The report's fields on each product or supplier row (assessment flags, main markets, the profile sections). |
| `excludeIds` | `excludeIds` | Supplier ids, as on the leader, or product ids. |
| `sortBy` | `sortBy` | The same values: `relevance` (Alibaba's own order, the default) or `sales_volume` (Alibaba's own sort by the units sold in the last 180 days). |
| `minPrice` | `minPrice` |  |
| `maxPrice` | `maxPrice` |  |
| `maxMOQ` | `maxMOQ` |  |
| `supplierCountries` | `supplierCountries` | Two-letter codes. |
| `minReviewScore` | `minReviewScore` |  |
| `verifiedSupplier` | `verifiedSupplier` |  |
| `verifiedManufacturer` | *not read* | Alibaba's search has no such filter; the business type is on each row with `includeDetails`. |
| `tradeAssurance` | *not read* | Not a filter: every product Alibaba lists carries Trade Assurance (59 of 59 product pages); `trade_assurance` is on each detailed row. |
| `verifiedProSupplier` | `verifiedProSupplier` |  |
| `companyAuthTags` | `companyAuthTags` |  |
| `productCertTags` | `productCertTags` |  |
| `maxDeliveryDays` | `maxDeliveryDays` | Alibaba's filter offers 18, 24 and 30 days; another value is read as the next lower one. |
| `localStock` | `localStock` | The view's own local-stock value (US, EU) is read from Alibaba's first page. |
| `paidSamples` | *not read* | Not a filter Alibaba honours (the same list came back); the sample's price is on each row with `includeDetails`. |
| `guaranteed` | `guaranteed` |  |
| `includeReviews` | *not read* | Store reviews are not readable logged out (the review list renders empty); the store's rating and review count are on every row. |
| `maxReviewsPerProduct` | *not read* | Reviews are not served (see `includeReviews`). |
| `feedback` | `feedback` | The same: a free-text note to the maintainers. The run does not read it; a person does. |

**What differs:**

- The leader's row is a product with its page; here the page is the `includeDetails` switch (on for product URLs and storefronts), so a search without it is the listing's fields at the listing's price.
- `maxResults` is read as `maxItemsPerQuery` (per input, as the leader's is per keyword); `maxItems` caps the whole run.
- `resultType: suppliers` reads the keywords as supplier searches (`supplierQueries`); `resultType: category` reads the `category` name as search words (a category URL in `startUrls` reads the category itself).
- `excludeIds` takes product ids as well as supplier ids.
- Not served here: the Worldwide marketplace, store reviews, the Verified Manufacturer, Trade Assurance and paid-samples filters (each named in the run's notes when you set it).

### Output

One row per product (or supplier), and one free search row per input:

| field | meaning |
|---|---|
| `row_type` | `product` (one product, charged), `supplier` (one supplier of a supplier search, charged) or `search` (the input's own row with its verdict; free). |
| `input_index` | The 1-based position of the input this row answers: `searchQueries` first, then `startUrls`, `productUrls`, `imageUrls`, `supplierQueries`. |
| `input_value` | The input as you gave it (the search words, the URL, the id). |
| `input_kind` | What the input is: `query` (search words), `url` (a search URL), `category`, `product` (a product URL or id), `store` (a storefront), `image` (an image URL) or `supplier_query` (supplier search words). |
| `query` | The search's words (a URL's `SearchText`, a category's words); null for a product, a storefront or an image. |
| `search_url` | The search on Alibaba, as a URL you can open. |
| `status` | A search row: `ok`, `invalid`, `duplicate`, `failed`, `not_read`, `not_found`, `no_results` or `not_offered` (see the FAQ). A product or supplier row: `ok`. |
| `status_detail` | A search row: why it is not `ok`, or how the input was read (a URL form, the local-stock value), in a sentence. |
| `scraped_at` | When the row was read (ISO 8601, UTC). |
| `position` | The row's place among this input's delivered products or suppliers (1 = first), in Alibaba's order. |
| `page` | The list page the row was on (48 products a search page, 16 a storefront page, 100 an image search page); null for a product URL. |
| `product_id` | Alibaba's product id (the number in the product URL). |
| `url` | The product's page on Alibaba. |
| `title` | The product's title as the listing shows it (the page's title for a product URL). |
| `price` | The price or price range as Alibaba shows it in the row's view and currency (`$0.45-1.04`, `€2.07-2.87`, `51-70,74 CZK`). |
| `price_min` | The lowest number of the price (the price itself when there is one), in `currency`. |
| `price_max` | The highest number of the price (the price itself when there is one), in `currency`. |
| `currency` | The prices' currency: the one you asked (`currency`, default `USD`); every page is checked to be in it. |
| `moq` | The minimum order as the listing shows it (`Min. order: 5 meters`). |
| `moq_quantity` | The minimum order's quantity (5). |
| `moq_unit` | The minimum order's unit (`meters`, `pieces`, `sets` …). |
| `image_url` | The product's main image, full size. |
| `images` | The listing's gallery, full size (up to six images; every image of the page is in `gallery`). |
| `certifications` | The product certifications the listing shows (`CE`, `RoHS`, `FCC` …); empty when it shows none. |
| `orders` | How many units were sold, where Alibaba shows a sold count (`4,672 sold` = 4672); null otherwise. |
| `is_ad` | True for a sponsored listing (an ad in the search). |
| `supplier_name` | The supplier's company name. |
| `supplier_id` | Alibaba's company id of the supplier. |
| `supplier_country` | The supplier's country as Alibaba codes it: the ISO code (`CN`, `HK`, `US` …), except `UK` for the United Kingdom. |
| `supplier_years` | The supplier's years on Alibaba (`9 yrs` = 9). |
| `supplier_url` | The supplier's store on Alibaba. |
| `supplier_profile_url` | The supplier's company profile page on Alibaba. |
| `verified_supplier` | True when Alibaba shows the Verified badge (a third-party audit of the supplier). |
| `verified_by` | The auditor the Verified badge names (`TÜV Rheinland`, `SGS`, `Intertek` …); null without the badge (and on image-search rows, whose listing does not name it). |
| `verified_pro` | True when Alibaba shows the Verified Pro badge. |
| `gold_supplier` | True when Alibaba shows the Gold Supplier badge. |
| `supplier_rating` | The supplier's store rating (out of 5), where it has reviews. |
| `review_count` | The number of reviews behind the store rating. |
| `products_count` | A search row: Alibaba's own count of results on page 1 (it moves between calls; the list a reader can walk is often shorter). |
| `products_delivered` | A search row: the product rows this input delivered. |
| `pages_read` | A search row: the list pages read. |
| `repeats_skipped` | A search row: products or suppliers skipped because an earlier page or another input of the run already delivered them. |
| `verdict` | A search row: COMPLETE (Alibaba's own end of the list), CAPPED (your limit), TRUNCATED (Alibaba's depth limit below its own count, or the walk's page limit) or PARTIAL (a refusal or the time limit). |
| `verdict_detail` | A search row: the verdict in a sentence: how many rows from how many pages and why the walk stopped. |
| `ship_to_country` | The view the row was read in: the ship-to country you asked (`shipToCountry`, default `US`); every answer is checked to be in it. |
| `promotion_price` | The promotion price the listing shows beside the price, where it shows one. |
| `discount` | The discount the listing shows (`21% off`). |
| `delivery_estimate` | The delivery estimate the listing shows for the view (`Delivery by Dec 16`). |
| `selling_point` | The listing's selling point (`Easy Return`, `Money-back guarantee`). |
| `tariff_note` | The listing's tariff note (`4% tariff support`), where it shows one. |
| `guaranteed` | True when the listing carries Alibaba's Guaranteed badge. |
| `local_stock` | True when the listing shows the local-stock badge for the view. |
| `customizable` | True when the listing says the product can be customized. |
| `company_certifications` | The supplier's management certifications the listing shows (`ISO`, `BSCI` …). |
| `supplier_service_score` | The supplier's service score on the listing (out of 5). |
| `shipping_score` | The supplier's shipping score on the listing (out of 5). |
| `product_score` | The product's score on the listing (out of 5). |
| `details_status` | Whether the product page was read for this row: `ok`, `failed` (Alibaba did not serve it: the row keeps the listing's fields and is not charged `details`), `not_found`; null when it was not asked. |
| `category_path` | The product's category path on Alibaba (`Home & Garden` › … › `Plastic Drinkware`). |
| `category_id` | Alibaba's id of the product's category. |
| `price_ladder` | The price by quantity: one tier each with `min_quantity`, `max_quantity` (null for the last tier), `price` (in `currency`), `price_usd` and `price_text`; empty for a product priced by SKU. |
| `price_range_usd` | The product's lowest and highest price in USD (`[1.0, 2.0]`). |
| `price_unit` | The unit the price is for (`piece`, `set` …). |
| `sku_attributes` | The product's variant dimensions with their values (`Color`: Grey, Pink …; `Capacity`: 500ml …). |
| `skus` | Every SKU: `sku_id`, its `attributes` (dimension → value), `price` and `price_usd` where the SKU has its own, and `stock`. |
| `specs` | The product's attributes as the page lists them: `name` and `value` (Material, Capacity, Brand …). |
| `gallery` | Every image of the product page, full size, in the page's order. |
| `video_url` | The product video's URL, where the page has one. |
| `description` | The seller's description as text (the page's own description blocks, or its HTML description). |
| `description_images` | The images of the seller's description. |
| `description_source` | Where the description came from: `page` (the page's own blocks), `html` (the HTML description), `none` (the product has none: a second read agreed) or `failed`. |
| `certificates` | The certificate documents: `name`, `number`, `type`, `valid_period` and `owner`. |
| `lead_times` | The lead time by quantity: `min_quantity`, `max_quantity`, `days`. |
| `sample_available` | True when the supplier sells a sample. |
| `sample_price` | The sample's price (in `currency`). |
| `customization` | The customization the supplier offers (`Minor customization`, `Drawing-based customization` …). |
| `price_term` | The price term (`FOB` …). |
| `unit_weight_kg` | The unit's weight in kg. |
| `unit_size_cm` | The unit's size in cm (`10X10X10`). |
| `ships_from` | The places of dispatch (`China`, `United States` …). |
| `trade_assurance` | True when the product carries Alibaba's Trade Assurance (every listed product did in our reads: 59 of 59). |
| `product_review_count` | The product's own review count, where it has reviews. |
| `business_type` | The supplier's business type (`Manufacturer`, `Trading Company` …). |
| `supplier_identity` | The supplier's label on the page (`Custom Manufacturer`, `Multispecialty Supplier`). |
| `supplier_city` | The supplier's city. |
| `supplier_location` | The supplier's location as the page states it (`Located in Hangzhou, Zhejiang, CN`). |
| `staff` | The supplier's staff (`15`, `170+ staff`). |
| `floorspace` | The supplier's floorspace (`542m²`). |
| `online_revenue` | The supplier's online revenue band (`$2M — $5M`). |
| `on_time_delivery` | The supplier's on-time dispatch rate (`97.9%`). |
| `response_time` | The supplier's response time (`≤4h`). |
| `reorder_rate` | The supplier's reorder rate (`14%`), where the page shows it. |
| `orders_6m` | The supplier's orders in the last 6 months. |
| `revenue_6m_usd` | The supplier's online revenue in the last 6 months, in USD. |
| `revenue_6m_text` | The same as the page shows it (`2,100,000+`). |
| `supplier_verified_by` | The inspection agency the page's company card names (`SGS Group`). |
| `supplier_medal` | The supplier's membership the page names (`Gold Supplier`). |
| `main_products` | A supplier row: the supplier's main products. |
| `factory_area` | A supplier row: the factory area (`22,000+ m²`). |
| `transactions_6m` | A supplier row: the supplier's transactions in the last 6 months as shown (`US $720,000+`). |
| `capabilities` | A supplier row: the capability tags (`OEM for well-known brands`, `Finished product inspection` …). |
| `sample_product_id` | A supplier row: the id of the product the suppliers tab shows for it. |
| `sample_product_url` | A supplier row: that product's page. |
| `sample_product_title` | A supplier row: that product's title. |
| `sample_product_price` | A supplier row: that product's price as shown. |
| `report_status` | Whether the supplier's report was read (`includeSupplierReport`): `ok` or `failed`; null when it was not asked. |
| `assessed` | The report: true when the supplier passed Alibaba's assessment. |
| `onsite_checked` | The report: true when the supplier passed the on-site check. |
| `business_type_verified` | The report: the verified business type (`Manufacturer, Trading Company`). |
| `main_markets` | The supplier's main markets: the report's with their shares (`North America` 50.00% …); on a details row without the report, the product page's names alone. |
| `response_rate` | The report: the supplier's response rate (`99.78%`). |
| `registered_country` | The report: the supplier's registered country as Alibaba codes it (the ISO code, except `UK` for the United Kingdom). |
| `trade_assurance_limit_usd` | The supplier's Trade Assurance limit in USD (the report's, or the product page's on a details row). |
| `orders_6m_report` | The report: the supplier's orders in the last 6 months. |
| `report_sections` | The report's profile sections (Company Overview, Product Capacity, Quality Control, R\&D Capacity, Trade Capability, Customers Cases), each with its items' `title`, `description` and `image_url`. |
| `suppliers_delivered` | A search row of a supplier search: the supplier rows it delivered. |
| `excluded_skipped` | A search row: products or suppliers skipped because `excludeIds` names them. |
| `ads_skipped` | A search row: sponsored products skipped (`skipAds`). |
| `exit_country` | A search row: the country of the exit that read the input (the view's own where the proxy has it, else `US`; `datacenter` on the fallback). |
| `video_id` | The product video's id on the page (`video.videoId`), also where the page gives no video URL. |
| `video_cover` | The product video's cover image URL. |
| `customization_options` | The page's customization offers, each with its kind, the option and its MOQ (`Logo/Pattern`, `Laser Carving`, 50 pieces). |
| `store_rating` | The store's rating on the product page (the supplier's reviews over every product). |
| `store_review_count` | The store's review count on the product page (on a search row `review_count` is the listing card's). |

Example record:

```json
{
  "row_type": "product",
  "input_index": 1,
  "input_value": "insulated water bottle",
  "input_kind": "query",
  "query": "insulated water bottle",
  "search_url": "https://www.alibaba.com/trade/search?SearchText=insulated+water+bottle",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-11-04T13:29:07Z",
  "position": 1,
  "page": 1,
  "product_id": "1600110762432",
  "url": "https://www.alibaba.com/product-detail/500ml-Business-Gift-Temperature-Display-Smart_1600110762432.html",
  "title": "500ml Business Gift Temperature Display Smart Water Bottles Double Walled Stainless Steel Vacuum Insulated Digital Cups",
  "price": "$1.98",
  "price_min": 1.98,
  "price_max": 1.98,
  "currency": "USD",
  "moq": "Min. order: 100 pieces",
  "moq_quantity": 100,
  "moq_unit": "pieces",
  "image_url": "https://s.alicdn.com/@sc04/kf/Hdf0575531be94aaab6a5e6d1905dc866R.jpg",
  "images": [
    "https://s.alicdn.com/@sc04/kf/Hdf0575531be94aaab6a5e6d1905dc866R.jpg",
    "https://s.alicdn.com/@sc04/kf/Hf0c02945ebcf4ec293045289238dbb48w.jpg",
    "https://s.alicdn.com/@sc04/kf/Hbad422a98cb64020a8d500a92280637dc.jpg",
    "https://s.alicdn.com/@sc04/kf/H962e1fef7e7f4aea9e7bf3d73db63210C.jpg",
    "https://s.alicdn.com/@sc04/kf/Hf526e390b896473a86907bf8824ea87bd.jpg",
    "https://s.alicdn.com/@sc04/kf/He1db3b1536d64662b0a15e0dc965ba58S.jpg"
  ],
  "certifications": [
    "CE"
  ],
  "orders": 339,
  "is_ad": true,
  "supplier_name": "Hangzhou Medo Import And Export Co., Ltd.",
  "supplier_id": "230538595",
  "supplier_country": "CN",
  "supplier_years": 12,
  "supplier_url": "https://medo.en.alibaba.com/",
  "supplier_profile_url": "https://medo.en.alibaba.com/company_profile.html",
  "verified_supplier": true,
  "verified_by": "SGS",
  "verified_pro": false,
  "gold_supplier": true,
  "supplier_rating": 4.8,
  "review_count": 56,
  "products_count": null,
  "products_delivered": null,
  "pages_read": null,
  "repeats_skipped": null,
  "verdict": null,
  "verdict_detail": null,
  "ship_to_country": "US",
  "promotion_price": null,
  "discount": null,
  "delivery_estimate": "Delivery by Jan 29",
  "selling_point": "Easy Return",
  "tariff_note": null,
  "guaranteed": false,
  "local_stock": null,
  "customizable": false,
  "company_certifications": [
    "FSC",
    "ISO",
    "BSCI"
  ],
  "supplier_service_score": 4.7,
  "shipping_score": 4.8,
  "product_score": 4.8,
  "details_status": "ok",
  "category_path": [
    "Home & Garden",
    "Drinkware & Accessories",
    "Drinkware",
    "Smart Drinkware"
  ],
  "category_id": "201348002",
  "price_ladder": [
    {
      "min_quantity": 100,
      "max_quantity": 199,
      "price": 1.98,
      "price_usd": 1.98,
      "price_text": "$1.98"
    },
    {
      "min_quantity": 200,
      "max_quantity": 9999,
      "price": 1.85,
      "price_usd": 1.85,
      "price_text": "$1.85"
    },
    {
      "min_quantity": 10000,
      "max_quantity": null,
      "price": 1.6,
      "price_usd": 1.6,
      "price_text": "$1.60"
    }
  ],
  "price_range_usd": [
    1.6,
    1.98
  ],
  "price_unit": "piece",
  "sku_attributes": [
    {
      "name": "Volume",
      "values": [
        "500ml"
      ]
    },
    {
      "name": "Capacity",
      "values": [
        "500ml"
      ]
    },
    {
      "name": "Color",
      "values": [
        "Black",
        "Blue",
        "Purple",
        "Red"
      ]
    }
  ],
  "skus": [
    {
      "sku_id": "109537313180",
      "attributes": {
        "Volume": "500ml",
        "Capacity": "500ml",
        "Color": "Natural"
      },
      "price": null,
      "price_usd": null,
      "stock": null
    },
    {
      "sku_id": "109537313182",
      "attributes": {
        "Volume": "500ml",
        "Capacity": "500ml",
        "Color": "Deep Blue"
      },
      "price": null,
      "price_usd": null,
      "stock": null
    },
    {
      "sku_id": "109537313181",
      "attributes": {
        "Volume": "500ml",
        "Capacity": "500ml",
        "Color": "Gray"
      },
      "price": null,
      "price_usd": null,
      "stock": null
    }
  ],
  "specs": [
    {
      "name": "Plastic Type",
      "value": "ABS"
    },
    {
      "name": "Feature",
      "value": "Eco-Friendly, Stocked, Business, Temperature Display, WITH LID"
    },
    {
      "name": "Ceramic Type",
      "value": "stainless steel"
    }
  ],
  "gallery": [
    "https://sc04.alicdn.com/kf/Hdf0575531be94aaab6a5e6d1905dc866R.jpg",
    "https://sc04.alicdn.com/kf/Hf0c02945ebcf4ec293045289238dbb48w.jpg",
    "https://sc04.alicdn.com/kf/Hbad422a98cb64020a8d500a92280637dc.jpg"
  ],
  "video_url": "https://gv.videocdn.alibaba.com/3e0b62b9bd1fee42/default/mi8aLNRqECJ1ADj8JlE_mp4_339558729802_mp4_264_hd_unlimit_aliyun.mp4?bizCode=icbu_vod_video",
  "description": "This 500ml premium insulated bottle comes with a smart temperature display lid and a removable tea infuser for easy tea brewing. Offering reliable 12 plus hour heat and cold retent …(truncated for display)",
  "description_images": [
    "https://sc04.alicdn.com/kf/H9c4be670e7f74412bec4b22b279e8d6dF.jpg",
    "https://sc04.alicdn.com/kf/Hba9074c623244749a5e8ae49c5ff2f6al.jpg",
    "https://sc04.alicdn.com/kf/H649fefba57eb488c94af163b4a124db81.jpg"
  ],
  "description_source": "page",
  "certificates": [
    {
      "name": "CE",
      "number": "SHEM221000846601TXC",
      "type": "PRODUCT",
      "valid_period": "11/08/2022 - 11/08/2027",
      "owner": "Supplier-owned"
    },
    {
      "name": "BPA",
      "number": "UNIB25012401HR-01",
      "type": "INSPECTION_REPORT",
      "valid_period": "01/23/2025 - 01/22/2027",
      "owner": "Supplier-owned"
    },
    {
      "name": "BPA",
      "number": "NGBHL22003682801",
      "type": "INSPECTION_REPORT",
      "valid_period": "10/27/2022 - 03/23/2027",
      "owner": "Supplier-owned"
    }
  ],
  "lead_times": [
    {
      "min_quantity": 1,
      "max_quantity": 1000,
      "days": 10
    }
  ],
  "sample_available": true,
  "sample_price": 3,
  "customization": [
    "Minor customization",
    "Drawing-based customization"
  ],
  "price_term": "FOB",
  "unit_weight_kg": 0.348,
  "unit_size_cm": "10X10X26",
  "ships_from": [
    "China"
  ],
  "trade_assurance": true,
  "product_review_count": 1,
  "business_type": "Manufacturer,Trading Company",
  "supplier_identity": "Custom Manufacturer",
  "supplier_city": "Hangzhou",
  "supplier_location": "Located in Hangzhou, Zhejiang, CN",
  "staff": "101-200",
  "floorspace": null,
  "online_revenue": "US$720,000+",
  "on_time_delivery": "98.0%",
  "response_time": "≤2h",
  "reorder_rate": "17%",
  "orders_6m": 269,
  "revenue_6m_usd": 728128.0200000003,
  "revenue_6m_text": "720,000+",
  "supplier_verified_by": "SGS Group",
  "supplier_medal": "Gold Supplier",
  "main_products": null,
  "factory_area": null,
  "transactions_6m": null,
  "capabilities": null,
  "sample_product_id": null,
  "sample_product_url": null,
  "sample_product_title": null,
  "sample_product_price": null,
  "report_status": null,
  "assessed": null,
  "onsite_checked": null,
  "business_type_verified": null,
  "main_markets": null,
  "response_rate": null,
  "registered_country": null,
  "trade_assurance_limit_usd": null,
  "orders_6m_report": null,
  "report_sections": null,
  "suppliers_delivered": null,
  "excluded_skipped": null,
  "ads_skipped": null,
  "exit_country": null,
  "video_id": null,
  "video_cover": null,
  "customization_options": null,
  "store_rating": null,
  "store_review_count": null
}
```

### Pricing

**Pay for the rows a run delivers**, plus one run start; no platform usage is billed to you. The prices fall with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Product (`product`) | per 1,000 | $5.00 | $4.25 | $3.50 | $2.50 |
| Product page (`details`) | per 1,000 | $0.75 | $0.75 | $0.75 | $0.75 |
| Supplier (`supplier`) | per 1,000 | $5.00 | $4.25 | $3.50 | $2.50 |
| Supplier report (`supplier_report`) | per 1,000 | $1.99 | $1.6915 | $1.393 | $0.995 |
| Run start (`start`) | per run | $0.005 | $0.005 | $0.005 | $0.005 |

A product is **$5.00 per 1,000** on the Free plan; a product row that also carries its product page (`includeDetails`, a product URL, a storefront's product) adds the `details` event. Each run that delivers a charged row also pays the **run start, $0.005 once**; a run that delivers no charged row pays nothing at all. So one search of 100 products costs $0.505 on the Free plan and $0.430 on Starter; with the product page on every row $0.580 and $0.505. The free `search` row of every input, a value that names nothing (`invalid`), a repeated input (`duplicate`), a product Alibaba answers "Product Not Available" for (`not_found`), a search Alibaba lists nothing for (`no_results`), an input left at the cap or the time limit (`not_read`) and a refusal the run could not pass (`failed`) are never charged; a product page Alibaba does not serve leaves the card's row without the `details` charge. A product is charged once a run, also when several inputs list it. A run that stops early (a timeout, an abort) is charged for the rows it delivered. `maxItems` counts the charged rows; before the first request the log names the price of each row at your plan and the most the run can cost. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **What goes in** — `searchQueries`: the words you would type in Alibaba's search box. `startUrls`: an alibaba.com URL as your browser shows it — a search (its filters are kept), a category page, a `/products/`, `/showroom/` or `/countrysearch/` page (read as the search of its words), a product page or a supplier's storefront (`https://<name>.en.alibaba.com/`). `productUrls`: product URLs or ids. `imageUrls`: images to search by. `supplierQueries`: supplier search words.
- **What a row is** — `row_type` = `product`: one product, in Alibaba's order (`position`, and the `page` it was on), with the product page's fields when it was read (`details_status` ok). `row_type` = `supplier`: one supplier of a supplier search. `row_type` = `search`: the free row of one input value — `products_count` (Alibaba's own count), `products_delivered`, `suppliers_delivered`, `pages_read`, `repeats_skipped`, `excluded_skipped`, `ads_skipped`, the `verdict` with its `verdict_detail`, and the `status` with its reason.
- **How far an input goes** — `maxItemsPerQuery` (default 100; 0 = every row the input lists) stops each input after that many new products or suppliers. Alibaba answers a search from two lists: a short one that ends near page 36 (about 1,700 products) and a deep one past page 100; a walk goes to the list's own end and says TRUNCATED, with Alibaba's count, when that end is far below the count. A storefront is read to its last catalogue page (16 products a page), an image search to its last page (100 a page). `maxItems` caps the charged rows of the whole run.
- **The view and the currency** — `shipToCountry` (default US) is Alibaba's Deliver-to country: the list, the prices and what can ship there follow it. `currency` (default USD) is chosen apart from it. Every search page and product page is checked to be in both; with the product page on, each ladder tier carries its USD price as well.
- **The product page and the report** — `includeDetails` reads each product's page after the cap is decided, so a capped run reads no page it cannot deliver; a page Alibaba does not serve leaves the listing's row (`details_status` failed), not charged for the page. `includeSupplierReport` reads each supplier's report once a run from its storefront.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `searchQueries` | `array` |  | What to search for on Alibaba.com, one search a line (`led lights`), as you would type it in Alibaba's search box. Each search is read apart. Up to 100 searches, URLs, storefronts, images and supplier searches a run together. An empty line gets a free `invalid` row, a search given twice a free `duplicate` row. |
| `startUrls` | `array` |  | Alibaba.com URLs as your browser shows them: a search (`https://www.alibaba.com/trade/search?SearchText=led+strip+light`, with the filters you set there; they are kept), a category page (`/catalog/…_cid…`), a `/products/`, `/showroom/` or `/countrysearch/` page (read as the search of its words), a product page (read like `productUrls`) or a supplier's storefront (`https://<name>.en.alibaba.com/`, its product catalogue). A URL of another site gets a free `invalid` row. |
| `productUrls` | `array` |  | Alibaba.com product pages to read, one a line: the URL (`https://www.alibaba.com/product-detail/…_1600318274427.html`) or the id (`1600318274427`). Each row carries the whole product page (ladder, SKUs, specs, description, certificates, supplier profile). An id Alibaba answers "Product Not Available" for on two exits gets a free `not_found` row. Up to 1,000 a run. |
| `imageUrls` | `array` |  | Find products that look like an image: one image URL a line (JPEG, PNG, WebP). An image on Alibaba's own CDN (`*.alicdn.com`) is searched directly; any other image is downloaded by the run and uploaded to Alibaba's search by image. Alibaba gives no similarity score; the order is its own. |
| `supplierQueries` | `array` |  | Search Alibaba's suppliers (the Suppliers tab), one search a line (`insulated water bottle`). Each supplier is a `supplier` row: name, id, store and profile URLs, years, Verified and Verified Pro flags, rating and reviews, main products, factory area, staff, 6-month transactions, response time, capability tags and a sample product. |
| `maxItemsPerQuery` | `integer` | `100` | Stop each search, category, storefront, image or supplier search after this many products or suppliers (0 = every one it lists). A product Alibaba repeats on a later page, or one an earlier input of the run already delivered, is skipped and not counted. Alibaba lists about 1,700 products of an ordinary search to a reader on its small list and more on its big one, whatever its own count says. |
| `maxItems` | `integer` | `0` | Stop the run after this many product and supplier rows across every input (0 = no limit). Search rows are free and not counted; an input left unread at the cap gets a free `not_read` row. |
| `includeDetails` | `boolean` | `false` | For each product of a search, a category or an image search, also read its product page: the price ladder by quantity (in your currency and in USD), every SKU with its values, price and stock, the specs, the seller's description, certificate documents with number and validity, lead times, samples, customization, trade terms, places of dispatch, the category path and the supplier's profile (business type, staff, floorspace, revenue, on-time rate, response time, 6-month orders). Charged as `details` on each row that carries its page; a page Alibaba does not serve leaves the card's row, not charged for details. Product URLs and storefront products always carry their page. |
| `includeSupplierReport` | `boolean` | `false` | Add the supplier's verification report from its storefront: the assessment and on-site check flags, the verified business type, the main markets with their shares, the response rate, the Trade Assurance limit, and the profile sections (company overview, production capacity, quality control, R\&D, trade capability) with their items. Read once a run per supplier; charged as `supplier_report` on each row that carries it. |
| `shipToCountry` | `US` / `CN` / `DE` / `GB` / `FR` / `IT` / `ES` / `NL` / `BE` / `SE` / `PL` / `CH` / `AT` / `IE` / `DK` / `NO` / `FI` / `PT` / `GR` / `CZ` / `IN` / `JP` / `KR` / `HK` / `SG` / `MY` / `TH` / `VN` / `ID` / `PH` / `AE` / `SA` / `TR` / `IL` / `CA` / `MX` / `BR` / `AR` / `VE` / `AU` / `NZ` / `ZA` / `CL` / `CO` / `PE` / `EC` / `UY` / `RO` / `HU` / `BG` / `HR` / `SK` / `SI` / `LT` / `LV` / `EE` / `UA` / `PK` / `BD` / `TW` / `LK` / `QA` / `KW` / `BH` / `OM` / `JO` / `EG` / `NG` / `KE` / `MA` / `GH` | `"US"` | The country Alibaba shows the products for, as its "Deliver to" selector does: the list, its prices and what can ship there follow it. Every answer is checked to be in this view; a page in another one is never delivered. The run's exits are in this country where the proxy has them (US otherwise); each row says the view in `ship_to_country`. |
| `currency` | `AED` / `ARS` / `AUD` / `BDT` / `BHD` / `BRL` / `CAD` / `CHF` / `CLP` / `CNY` / `COP` / `CZK` / `DKK` / `EGP` / `EUR` / `GBP` / `GHS` / `HKD` / `HUF` / `IDR` / `ILS` / `INR` / `JOD` / `JPY` / `KES` / `KRW` / `KWD` / `LKR` / `MAD` / `MXN` / `MYR` / `NGN` / `NOK` / `NZD` / `OMR` / `PEN` / `PHP` / `PKR` / `PLN` / `QAR` / `RON` / `SAR` / `SEK` / `SGD` / `THB` / `TRY` / `TWD` / `UAH` / `USD` / `UYU` / `VND` / `ZAR` | `"USD"` | The currency of every price, chosen apart from the country (Alibaba converts at its own rate). `price`, `price_min` and `price_max` are in it; with details each ladder tier also carries its USD price. A page whose prices are not in this currency is never delivered. |
| `minPrice` | `number` |  | Only products priced at least this much (in the run's currency), as Alibaba's own price filter applies it. |
| `maxPrice` | `number` |  | Only products priced at most this much (in the run's currency). |
| `maxMOQ` | `integer` |  | Only products whose minimum order is at most this many units (0 = any). |
| `supplierCountries` | `array` |  | Only suppliers located in these countries: two-letter codes, one a line (`CN`, `US`, `IN`). |
| `verifiedSupplier` | `boolean` | `false` | Only suppliers verified by a third-party inspection (Alibaba's Verified Supplier filter). |
| `verifiedProSupplier` | `boolean` | `false` | Only Verified Pro suppliers. |
| `guaranteed` | `boolean` | `false` | Only products with Alibaba's Guaranteed delivery and price. |
| `productCertTags` | `array` |  | Only products with these certifications, one a line (`CE`, `ROHS`, `FSC`), as Alibaba's filter names them. |
| `companyAuthTags` | `array` |  | Only suppliers with these management certifications, one a line (`ISO`, `BSCI`, `SEDEX`). |
| `minReviewScore` | `any` / `4` / `4.5` / `5` | `"any"` | Only suppliers whose store rating is at least this. |
| `maxDeliveryDays` | `integer` |  | Only products Alibaba can deliver within this many days (its "Delivery by" filter offers 18, 24 and 30 days; another value is read as the next lower one; under 18 is refused). 0 = any. |
| `localStock` | `boolean` | `false` | Only products stocked in a warehouse that ships to your ship-to country (Alibaba's "Local stock"). The run reads the view's own filter value from Alibaba's first page (US in the US view, EU in European views); a view that offers none gets a free `not_offered` row. |
| `sortBy` | `relevance` / `sales_volume` | `"relevance"` | The order Alibaba lists the products in: its own relevance order, or its sort by the units sold in the last 180 days. A search URL's own sort stays the URL's. |
| `excludeIds` | `array` |  | Product ids or supplier ids you already have, one a line (`1600318274427`, `230538595`): a product with that id, or a product of that supplier, or that supplier, is skipped before it is counted or charged. Up to 500,000. |
| `skipAds` | `boolean` | `false` | Leave out the products Alibaba marks as ads. Off: they are delivered with `is_ad` true. |
| `egressFirst` | `string` | `"residential"` | For the maintainers' tests: the proxy the run leads with: `residential` (the default) or `datacenter` (Apify's datacenter group). Leave it as it is. |
| `feedback` | `string` |  | A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A value that names nothing (an empty line, a URL of another site, a page this Actor does not read) is not an error: it gets one free `search` row with `status` invalid that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

A search row's `status` is `ok` (rows served), `invalid` (an empty value, or a URL this Actor does not read), `duplicate` (the same input again: read once), `not_found` (a product Alibaba answers "Product Not Available" for, on two exits), `no_results` (a search Alibaba lists nothing for, on four fresh exits), `not_offered` (local stock asked in a view that offers none), `failed` (Alibaba refused every try; free) or `not_read` (left at `maxItems`, the charge limit or the run's time limit). A product or supplier row's `status` is `ok`.

**Does it give the price tiers, the SKUs and the specifications?**

Yes, with `includeDetails` (and always for a product URL or a storefront's product): `price_ladder`, `skus` with their prices and stock, `sku_attributes`, `specs`, `description`, `certificates`, `lead_times` and the supplier's profile come from each product's own page. Without it a row carries what the search listing shows, at the listing's price.

**Which country's prices are these?**

The country you ask in `shipToCountry` (71, US by default) in the currency you ask in `currency` (52, USD by default); every page is checked to be in that view, and each row says it in `ship_to_country` and `currency`. A decimal comma (`€ 2,07`) and the other local forms are read into `price_min` and `price_max`.

**Does it read store reviews or contact persons?**

No. Store reviews are not readable logged out (the review list renders empty); the store's rating and review count are on every row. Contact persons' names are never read.

**Does it need an Alibaba account or API key?**

No. Everything is read from Alibaba's public pages, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/alibaba-scraper').call({"searchQueries": ["led lights"], "maxItemsPerQuery": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/alibaba-scraper').call(run_input={'searchQueries': ['led lights'], 'maxItemsPerQuery': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/alibaba-scraper --input '{"searchQueries": ["led lights"], "maxItemsPerQuery": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~alibaba-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"searchQueries": ["led lights"], "maxItemsPerQuery": 100}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/alibaba-scraper` and ask, for example: "Get 100 Alibaba products for insulated water bottle with wholesale price tiers, MOQ, SKUs and the supplier profile". The agent fills the input from the table above and reads the rows from the run's dataset. A field under the name another Actor gives it is read as this Actor's own: `keywords`, `queries`, `searchTerms`, `keyword` as `searchQueries`; `urls`, `searchUrls`, `startUrl`, `url` as `startUrls`; `productIds`, `products`, `productUrl`, `productId` as `productUrls`; `images`, `imageUrl`, `image`, `photoUrls` as `imageUrls` (and more). An agent or a person can add `feedback` to any run and say what was needed and not delivered: a missing field, a wrong or empty result, the Actor switched from or to, and why. The run returns the same rows at the same price, and a person reads every note.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/alibaba-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[Amazon Product Details Scraper](https://apify.com/hyperbach/amazon-product-details-scraper)** — Amazon products by ASIN, URL or UPC / EAN / ISBN on 21 Amazon stores: the buy-box price, every best-seller rank, the rating and the review summary.
- **[AliExpress Product Details Scraper](https://apify.com/hyperbach/aliexpress-product-details-scraper)** — AliExpress products by URL or item id: every SKU with its own price and stock, in the country and currency you choose.
- **[Shopify Store Scraper](https://apify.com/hyperbach/shopify-products-scraper)** — every product of a Shopify store, with its variants, prices and images.
- **[Walmart Products Scraper](https://apify.com/hyperbach/walmart-scraper)** — Walmart products by search, category or URL: the price with the was-price, the seller and the rating.
- **[Coles Scraper](https://apify.com/hyperbach/coles-scraper)** — Coles Australia products and specials, with the price, the was-price and the unit price.
- **[Woolworths Scraper](https://apify.com/hyperbach/woolworths-scraper)** — Woolworths Australia products and specials, with the barcode, the unit price and nutrition.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

What to search for on Alibaba.com, one search a line (`led lights`), as you would type it in Alibaba's search box. Each search is read apart. Up to 100 searches, URLs, storefronts, images and supplier searches a run together. An empty line gets a free `invalid` row, a search given twice a free `duplicate` row.

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

Alibaba.com URLs as your browser shows them: a search (`https://www.alibaba.com/trade/search?SearchText=led+strip+light`, with the filters you set there; they are kept), a category page (`/catalog/…_cid…`), a `/products/`, `/showroom/` or `/countrysearch/` page (read as the search of its words), a product page (read like `productUrls`) or a supplier's storefront (`https://<name>.en.alibaba.com/`, its product catalogue). A URL of another site gets a free `invalid` row.

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

Alibaba.com product pages to read, one a line: the URL (`https://www.alibaba.com/product-detail/…_1600318274427.html`) or the id (`1600318274427`). Each row carries the whole product page (ladder, SKUs, specs, description, certificates, supplier profile). An id Alibaba answers "Product Not Available" for on two exits gets a free `not_found` row. Up to 1,000 a run.

## `imageUrls` (type: `array`):

Find products that look like an image: one image URL a line (JPEG, PNG, WebP). An image on Alibaba's own CDN (`*.alicdn.com`) is searched directly; any other image is downloaded by the run and uploaded to Alibaba's search by image. Alibaba gives no similarity score; the order is its own.

## `supplierQueries` (type: `array`):

Search Alibaba's suppliers (the Suppliers tab), one search a line (`insulated water bottle`). Each supplier is a `supplier` row: name, id, store and profile URLs, years, Verified and Verified Pro flags, rating and reviews, main products, factory area, staff, 6-month transactions, response time, capability tags and a sample product.

## `maxItemsPerQuery` (type: `integer`):

Stop each search, category, storefront, image or supplier search after this many products or suppliers (0 = every one it lists). A product Alibaba repeats on a later page, or one an earlier input of the run already delivered, is skipped and not counted. Alibaba lists about 1,700 products of an ordinary search to a reader on its small list and more on its big one, whatever its own count says.

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

Stop the run after this many product and supplier rows across every input (0 = no limit). Search rows are free and not counted; an input left unread at the cap gets a free `not_read` row.

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

For each product of a search, a category or an image search, also read its product page: the price ladder by quantity (in your currency and in USD), every SKU with its values, price and stock, the specs, the seller's description, certificate documents with number and validity, lead times, samples, customization, trade terms, places of dispatch, the category path and the supplier's profile (business type, staff, floorspace, revenue, on-time rate, response time, 6-month orders). Charged as `details` on each row that carries its page; a page Alibaba does not serve leaves the card's row, not charged for details. Product URLs and storefront products always carry their page.

## `includeSupplierReport` (type: `boolean`):

Add the supplier's verification report from its storefront: the assessment and on-site check flags, the verified business type, the main markets with their shares, the response rate, the Trade Assurance limit, and the profile sections (company overview, production capacity, quality control, R\&D, trade capability) with their items. Read once a run per supplier; charged as `supplier_report` on each row that carries it.

## `shipToCountry` (type: `string`):

The country Alibaba shows the products for, as its "Deliver to" selector does: the list, its prices and what can ship there follow it. Every answer is checked to be in this view; a page in another one is never delivered. The run's exits are in this country where the proxy has them (US otherwise); each row says the view in `ship_to_country`.

## `currency` (type: `string`):

The currency of every price, chosen apart from the country (Alibaba converts at its own rate). `price`, `price_min` and `price_max` are in it; with details each ladder tier also carries its USD price. A page whose prices are not in this currency is never delivered.

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

Only products priced at least this much (in the run's currency), as Alibaba's own price filter applies it.

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

Only products priced at most this much (in the run's currency).

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

Only products whose minimum order is at most this many units (0 = any).

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

Only suppliers located in these countries: two-letter codes, one a line (`CN`, `US`, `IN`).

## `verifiedSupplier` (type: `boolean`):

Only suppliers verified by a third-party inspection (Alibaba's Verified Supplier filter).

## `verifiedProSupplier` (type: `boolean`):

Only Verified Pro suppliers.

## `guaranteed` (type: `boolean`):

Only products with Alibaba's Guaranteed delivery and price.

## `productCertTags` (type: `array`):

Only products with these certifications, one a line (`CE`, `ROHS`, `FSC`), as Alibaba's filter names them.

## `companyAuthTags` (type: `array`):

Only suppliers with these management certifications, one a line (`ISO`, `BSCI`, `SEDEX`).

## `minReviewScore` (type: `string`):

Only suppliers whose store rating is at least this.

## `maxDeliveryDays` (type: `integer`):

Only products Alibaba can deliver within this many days (its "Delivery by" filter offers 18, 24 and 30 days; another value is read as the next lower one; under 18 is refused). 0 = any.

## `localStock` (type: `boolean`):

Only products stocked in a warehouse that ships to your ship-to country (Alibaba's "Local stock"). The run reads the view's own filter value from Alibaba's first page (US in the US view, EU in European views); a view that offers none gets a free `not_offered` row.

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

The order Alibaba lists the products in: its own relevance order, or its sort by the units sold in the last 180 days. A search URL's own sort stays the URL's.

## `excludeIds` (type: `array`):

Product ids or supplier ids you already have, one a line (`1600318274427`, `230538595`): a product with that id, or a product of that supplier, or that supplier, is skipped before it is counted or charged. Up to 500,000.

## `skipAds` (type: `boolean`):

Leave out the products Alibaba marks as ads. Off: they are delivered with `is_ad` true.

## `egressFirst` (type: `string`):

For the maintainers' tests: the proxy the run leads with: `residential` (the default) or `datacenter` (Apify's datacenter group). Leave it as it is.

## `feedback` (type: `string`):

A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note.

## Actor input object example

```json
{
  "searchQueries": [
    "led lights"
  ],
  "maxItemsPerQuery": 50,
  "maxItems": 100,
  "includeDetails": false,
  "includeSupplierReport": false,
  "shipToCountry": "US",
  "currency": "USD",
  "verifiedSupplier": false,
  "verifiedProSupplier": false,
  "guaranteed": false,
  "minReviewScore": "any",
  "localStock": false,
  "sortBy": "relevance",
  "skipAds": false,
  "egressFirst": "residential"
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per product (or supplier), and one free search row per input:

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

How the run went: the product and supplier rows charged, the product pages and reports read, the free rows, the inputs by status, the walk per input (rows delivered, pages read, repeats skipped, the verdict), the view, the source counters (calls by kind, served, refused, exits, rotations, bytes, the slowest served answer per kind) and the memory watch.

# 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": [
        "led lights"
    ],
    "maxItemsPerQuery": 50,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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": ["led lights"],
    "maxItemsPerQuery": 50,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/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": [
    "led lights"
  ],
  "maxItemsPerQuery": 50,
  "maxItems": 100
}' |
apify call hyperbach/alibaba-scraper --silent --output-dataset

```

## MCP server setup

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