# Alibaba Listings Scraper & Supplier Profiles (`simpleapi/alibaba-listings-scraper`) Actor

Scrape Alibaba product listings and supplier profiles to collect product names, prices, minimum order quantities, ratings, supplier details, locations, certifications, and contact information for sourcing, supplier discovery, competitor research, and B2B lead generation.

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 — Products, Prices and Supplier Profiles

Alibaba listings scraper that turns a keyword or a pasted Alibaba search URL into structured listing rows — title, price, MOQ, product images — each one carrying the supplier behind it: company ID, minisite URL, service/product/shipping scores and star level. Turn on the supplier profile lookup and every unique supplier also gets Alibaba's own audited flag, years on the platform and paid-membership status, read straight off the supplier's minisite rather than guessed from the listing. Built for sourcing teams, dropshippers and supplier-vetting workflows that need to filter a huge catalogue down to suppliers worth contacting.

***

### What is Alibaba Listings Scraper & Supplier Profiles?

Alibaba Listings Scraper & Supplier Profiles is an Apify Actor that queries Alibaba's own search endpoint for a keyword or a pasted search URL and returns one structured JSON row per listing, with the supplier's identity, scores and (optionally) verification status attached. No Alibaba account, login or API key is needed — the Actor talks to Alibaba's public search and minisite pages the same way a browser does.

- **Discovery by keyword or by URL** — paste a plain keyword or a full `alibaba.com/trade/search` URL; a pasted URL's filters (country, price range, MOQ, product-auth tag, category, page) are read and re-sent rather than discarded.
- **Supplier identity on every row** — `companyName`, `companyId`, `countryCode`, `supplierProfileUrl` and `supplierStoreUrl` ship for free, no extra request.
- **Optional supplier audit lookup** — one request per unique supplier reads the minisite for `isAudited`, `yearsOnAlibaba` and `isPaidMember`, cached for the whole run.
- **Quality and scoring fields** — `supplierService`, `productScore`, `shippingScore`, `displayStarLevel`, `storeReviewScore` and `storeReviewCount` come straight from Alibaba's ranking data.
- **Server-side filters** — minimum store rating, assessed/verified suppliers, and a strict client-side audited-only filter.
- **Structured JSON output** — every row lands in an Apify dataset, downloadable as JSON, CSV or Excel, or read straight through the Apify API.

***

### What data can I extract with Alibaba Listings Scraper & Supplier Profiles?

Every push carries the full listing plus the supplier block; the fields below are every key the Actor writes, not just the ones shown in the default dataset view.

| Field | Example value | Use case |
| --- | --- | --- |
| `title` | "10 Pcs CNC Machined Aluminum Parts Custom" | product identification |
| `price` | "US$ 12.50-15.00" | pricing as Alibaba prints it |
| `promotionPrice` | "" | rare promo price when Alibaba shows one |
| `discount` | `null` | discount label when Alibaba shows one |
| `moq` | "Min. order: 2 pieces" | minimum order filtering |
| `priceCurrency` | "USD" | ISO code read off the price string |
| `productUrl` | "https://www.alibaba.com/product-detail/..." | link to the live listing |
| `productId` | "1600123456789" | de-duplication key |
| `mainImage` | "https://s.alicdn.com/..." | product thumbnail |
| `reviewScore` | "4.8" | raw score exactly as printed |
| `reviewCount` | 132 | raw review count |
| `deliveryEstimate` | "Ships in 7 days" | logistics planning, present on a minority of listings |
| `goldSupplierYears` | "5" | years as a Gold Supplier, blank when Alibaba doesn't show it |
| `input_url` | "cnc machining parts" | which search produced the row |
| `companyName` | "Shenzhen ABC Hardware Co., Ltd." | supplier identification |
| `companyId` | "123456789" | stable supplier key across listings |
| `countryCode` | "CN" | supplier location |
| `supplierProfileUrl` | "https://abchardware.trustpass.alibaba.com/" | supplier minisite link |
| `supplierStoreUrl` | "https://abchardware.en.alibaba.com/" | supplier storefront link |
| `supplierService` | 4.9 | service-quality score |
| `productScore` | 4.8 | product-quality score |
| `shippingScore` | 4.7 | shipping-quality score |
| `displayStarLevel` | 5 | Alibaba's star rating |
| `storeReviewScore` | 4.8 | numeric version of `reviewScore` used for filtering |
| `storeReviewCount` | 132 | numeric version of `reviewCount` |
| `listingsFromThisSupplier` | 3 | how many rows from this search matched this supplier |
| `isAudited` | true | `companyHasPassAssessment` from the supplier minisite |
| `yearsOnAlibaba` | 8 | account tenure from the minisite |
| `isPaidMember` | true | paid-membership flag from the minisite |
| `profileFetched` | true | `true` only when the minisite really answered and parsed |
| `supplierProfileNote` | `null` | why a profile field is missing, when it is |

#### Supplier trust and scoring data

`isAudited`, `yearsOnAlibaba` and `isPaidMember` come from the supplier's minisite, not from the search page, and only populate when `fetchSupplierProfiles` is on. `isAudited` mirrors Alibaba's own `companyHasPassAssessment` flag — the platform's real assessment marker, not an inference from star rating. `supplierService`, `productScore` and `shippingScore` are Alibaba's own per-supplier quality scores; combined with `displayStarLevel` and `storeReviewScore`, they let you rank suppliers behind otherwise-identical listings before you reach out to any of them.

#### Targeting and segmentation fields

`countryCode` and `companyId` group listings by supplier and by sourcing region. `listingsFromThisSupplier` shows how concentrated a search result is around a handful of manufacturers, which matters when `oneRowPerSupplier` is on. `priceCurrency` and `moq` let you segment by budget and order size, and `input_url` traces every row back to the keyword or URL that produced it when you run several searches in one job.

***

### Why not build this yourself?

Alibaba's search results aren't behind a stable, documented API a third party can just call — pulling them at any real volume means reverse-engineering an undocumented endpoint that punishes automated traffic. This Actor's own code notes it directly: a blocked request comes back as **HTTP 200** with a JSON body containing `FAIL_SYS_USER_VALIDATE` or `x5secdata` — never a 403, never a captcha page — so a scraper that only checks the status code sees every blocked request as a success. A cold session is punished on its very first request; only a session warmed with a `GET /` and a `GET /trade/search` first runs a long sequence clean.

Building this in-house means maintaining TLS-impersonation profiles that keep pace with browser fingerprinting, a warm-up sequence before every session, and a proxy escalation ladder (direct → datacenter → residential) for when a tier stops getting through — plus separately re-implementing the minisite parser that pulls the audited flag out of an obfuscated `module-data` blob. This Actor already does all of that: it reads Alibaba's own live filter menu per query instead of hardcoding categories, matches page size to what's actually left to fetch, and cross-checks the `onlyVerifiedSuppliers` server filter against the real audited flag it reads off each minisite.

If you only need a handful of listings once, opening Alibaba in a browser is faster than building anything. Past that, or the moment you need the supplier's real audited status and tenure attached to every row, this Actor replaces the maintenance burden of the anti-bot layer described above.

***

### How to use data extracted from Alibaba

#### Sourcing and procurement teams

Sourcing managers run a keyword or a category URL with `minSupplierRating` set to `"4.5~"` and `keepOnlyAuditedSuppliers` on, then work the output as a shortlist: `price`, `moq` and `countryCode` decide which listings fit the budget and lead time, while `companyId`, `supplierProfileUrl` and `isAudited` decide which suppliers are worth an RFQ. Because `keepOnlyAuditedSuppliers` drops rows whose minisite couldn't be read rather than guessing, the shortlist that comes out the other end is suppliers Alibaba itself has actually assessed — not suppliers that merely looked good in the search snippet.

#### Sourcing agencies and supplier-vetting services

Agencies that vet suppliers on behalf of clients run the same query on a schedule with `oneRowPerSupplier` on, collapsing hundreds of listings into one row per manufacturer with `listingsFromThisSupplier` showing how many products that supplier carries in the category. Comparing `isAudited`, `yearsOnAlibaba` and `storeReviewScore` across runs turns into a standing supplier scorecard clients can be handed directly, without re-verifying each supplier by hand.

#### Market research and pricing intelligence

Analysts run the same keyword across several `country`-filtered URLs and compare `price`, `priceCurrency` and `moq` by `countryCode` to map where a product category is priced competitively and where supply is concentrated. `displayStarLevel` and `storeReviewScore` distributions across the result set show whether a category is dominated by a few highly-rated suppliers or fragmented across many small ones.

#### AI agents and automated pipelines

Because the Actor runs as a standard Apify job with typed JSON output, it drops into an agent's tool belt as a "find and vet an Alibaba supplier" action — an agent passes a product keyword and a minimum rating, gets back ranked, audited-supplier rows, and hands `companyName`, `supplierProfileUrl` and `price` to a downstream RFQ-drafting step without any HTML to parse.

***

### 🔼 Input sample

Every field below matches `.actor/actor.json` exactly — same names, same types, same defaults.

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `urls` | Yes | array | One entry per line — a keyword or a full Alibaba search URL. A pasted URL's filters (country, pricef, pricet, moqt, productAuthTag, ta, categoryId, page) are re-sent to Alibaba. | `["cnc machining parts"]` |
| `limit` | No | integer (default `10`, min `0`, max `10000`) | How many listings to keep per search. `0` keeps going until Alibaba stops returning new listings, capped at 30 pages per search. | `50` |
| `fetchSupplierProfiles` | No | boolean (default `true`) | Reads each unique supplier's minisite for `isAudited`, `yearsOnAlibaba` and `isPaidMember`. One request per unique supplier, cached for the run. | `true` |
| `maxSupplierProfiles` | No | integer (default `25`, min `0`, max `500`) | Hard cap on minisite requests for the whole run. Suppliers past the cap still ship their row with `profileFetched = false`. | `25` |
| `oneRowPerSupplier` | No | boolean (default `false`) | Collapses the results into one row per supplier, keeping its first listing and setting `listingsFromThisSupplier`. | `false` |
| `keepOnlyAuditedSuppliers` | No | boolean (default `false`) | Drops every row whose minisite doesn't say `companyHasPassAssessment = true`. Requires `fetchSupplierProfiles`. | `false` |
| `onlyVerifiedSuppliers` | No | boolean (default `false`) | Sends `assessmentCompany=true` and `verifiedPro=1` to Alibaba's own search filters. | `false` |
| `minSupplierRating` | No | string, enum: `any`, `4~`, `4.5~`, `5~` (default `any`) | Sends Alibaba's `store_reviews` filter. Suppliers without a rating are excluded by Alibaba when this is set. | `"4.5~"` |
| `proxyConfiguration` | No | object (proxy editor) | Off means no proxy is used; a chosen group/country is what the requests actually run through. Alibaba prices follow the exit IP's currency. | Apify Proxy, RESIDENTIAL, country `US` |
| `autoEscalateWhenBlocked` | No | boolean (default `true`) | On a block, retries through Apify Proxy (direct → datacenter → residential) even if the proxy above is off. | `true` |

```json
{
  "urls": [
    "cnc machining parts",
    "https://www.alibaba.com/trade/search?SearchText=led+grow+light&country=US&moqt=5"
  ],
  "limit": 50,
  "fetchSupplierProfiles": true,
  "maxSupplierProfiles": 25,
  "oneRowPerSupplier": false,
  "keepOnlyAuditedSuppliers": false,
  "onlyVerifiedSuppliers": true,
  "minSupplierRating": "4.5~",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  },
  "autoEscalateWhenBlocked": true
}
```

⚠️ **Common pitfall:** `keepOnlyAuditedSuppliers` only ever keeps rows the Actor could actually verify — turn it on while `fetchSupplierProfiles` is off and every row is dropped, because `isAudited` never leaves `null` without the minisite lookup. Always leave `fetchSupplierProfiles` on when using the audited-only filter.

***

### 🔽 Output sample

Every row is typed, normalized JSON with a consistent schema — no column ever changes type between runs. The dataset is downloadable as JSON, CSV or Excel, or read through the Apify API. The Actor's default dataset view shows 23 of these columns; the remaining fields (`promotionPrice`, `discount`, `productId`, `reviewScore`, `reviewCount`, `deliveryEstimate`, `supplierStoreUrl`, `supplierProfileNote`) are still on every row, just not in the default table view.

```json
{
  "title": "10 Pcs CNC Machined Aluminum Parts Custom",
  "price": "US$ 12.50-15.00",
  "promotionPrice": "",
  "discount": null,
  "moq": "Min. order: 2 pieces",
  "priceCurrency": "USD",
  "productUrl": "https://www.alibaba.com/product-detail/CNC-Machined-Aluminum-Parts_1234567890.html",
  "productId": "1234567890",
  "mainImage": "https://s.alicdn.com/@sc04/kf/example.jpg",
  "reviewScore": "4.8",
  "reviewCount": 132,
  "deliveryEstimate": "Ships in 7 days",
  "goldSupplierYears": "5",
  "input_url": "cnc machining parts",
  "companyName": "Shenzhen ABC Hardware Co., Ltd.",
  "companyId": "123456789",
  "countryCode": "CN",
  "supplierProfileUrl": "https://abchardware.trustpass.alibaba.com/",
  "supplierStoreUrl": "https://abchardware.en.alibaba.com/",
  "supplierService": 4.9,
  "productScore": 4.8,
  "shippingScore": 4.7,
  "displayStarLevel": 5,
  "storeReviewScore": 4.8,
  "storeReviewCount": 132,
  "listingsFromThisSupplier": 3,
  "isAudited": true,
  "yearsOnAlibaba": 8,
  "isPaidMember": true,
  "profileFetched": true,
  "supplierProfileNote": null
}
```

Each row is billed once, as a `row_result` event. Filtering — `keepOnlyAuditedSuppliers`, `oneRowPerSupplier` collapsing — happens before the row is saved, so a row that gets filtered out is never pushed and never charged.

***

### How do you filter and target specific listings?

Getting a usable shortlist out of Alibaba's catalogue means combining four axes rather than relying on one.

**Keyword vs. pasted URL** — a plain keyword searches Alibaba broadly; a pasted `trade/search` URL is more precise because its `country`, `pricef`/`pricet`, `moqt`, `productAuthTag` and `categoryId` filters are read off the URL and re-sent as-is, and its `page` value becomes the starting page.

**Scope precision** — the same URL filters narrow by price band, minimum order quantity, product-auth tag and category before a single row is fetched, so you're paying for fewer, more relevant pages rather than filtering a broad pull afterward.

**Quality thresholds** — `minSupplierRating` sends Alibaba's own store-rating filter server-side; `onlyVerifiedSuppliers` sends `assessmentCompany=true` and `verifiedPro=1`; `keepOnlyAuditedSuppliers` is a strict client-side pass that only keeps rows this Actor could confirm via the supplier's minisite.

**Volume controls** — `limit` caps rows per search (`0` = unlimited, capped at 30 pages); `maxSupplierProfiles` caps minisite lookups for the whole run, independent of how many listing rows come back.

```json
{ "urls": ["https://www.alibaba.com/trade/search?SearchText=led+grow+light&country=US&pricef=10&pricet=50&moqt=100"], "limit": 200 }
```

```json
{ "urls": ["stainless steel water bottle"], "onlyVerifiedSuppliers": true, "minSupplierRating": "4.5~", "keepOnlyAuditedSuppliers": true, "fetchSupplierProfiles": true }
```

```json
{ "urls": ["cnc machining parts", "3d printing service", "sheet metal fabrication"], "limit": 0, "oneRowPerSupplier": true, "maxSupplierProfiles": 200 }
```

***

### ▶️ Want to try other marketplace scrapers?

| Scraper | What it extracts |
| --- | --- |
| Amazon Search Scraper By Country & Currency | Amazon search results per marketplace, with country and currency on every product row |
| Amazon Product Details Scraper (Bestsellers & New Releases) | Full product-detail records for every ranked item on an Amazon Best Sellers, New Releases or Most Wished For list |
| Shopify Products Scraper With Variant & SKU Rows | A Shopify storefront's catalogue, one row per product plus a child row per variant/SKU |
| Shopify Store Scraper — Markets, Currencies & Catalogs | Which markets a Shopify store sells in, and how its catalogue and prices change by market |
| Google Play Scraper: Country Pricing & In-App Purchases | A Google Play app's local price, in-app purchase tiers and availability across country storefronts |

***

### How to extract Alibaba data programmatically

The Actor runs as a standard Apify job: start it with one API call, poll or wait for the run, then read the dataset back as structured JSON.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "urls": ["cnc machining parts"],
    "limit": 50,
    "fetchSupplierProfiles": True,
    "minSupplierRating": "4.5~",
}

run = client.actor("simpleapi/alibaba-listings-scraper-and-supplier-profiles").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["price"], item["isAudited"])
```

#### Export to spreadsheets or CRM

Download the dataset as CSV directly from the run, or map fields on import: `companyName` → Company, `supplierProfileUrl` → Website, `price` and `moq` → Pricing columns, `isAudited` and `yearsOnAlibaba` → Verification columns. Every column name in the CSV export matches the JSON key exactly, so no relabeling is needed before the import.

***

### Is it legal to scrape Alibaba?

Yes — scraping publicly listed Alibaba search results and supplier minisites is legal; these pages exist specifically so buyers can find and evaluate products and suppliers without logging in. The records this Actor returns — product titles, prices, MOQs, company names, supplier scores and audited status — are business and product data, not personal data about an individual, so this falls under Alibaba's Terms of Service and database-rights considerations rather than GDPR or CCPA. Respect Alibaba's Terms of Service, don't overwhelm the site with requests, and don't republish scraped data as your own. Consult legal counsel for commercial applications involving bulk storage of personal data.

***

### ❓ FAQ

#### What happens if a supplier's minisite is unpublished or the listing is gone?

Alibaba serves an unpublished minisite as an HTTP 200 page with a client-side 404 shell rather than a real 404 status. When that happens, `isAudited`, `yearsOnAlibaba` and `isPaidMember` stay `null`, `profileFetched` is `false`, and `supplierProfileNote` explains why — nothing is ever guessed to fill the gap.

#### Can I get supplier profile data along with the main listing records?

Yes. With `fetchSupplierProfiles` on (the default), every unique supplier gets one cached minisite request for `isAudited`, `yearsOnAlibaba` and `isPaidMember`, capped for the whole run by `maxSupplierProfiles`. Suppliers past that cap still ship their listing row, just with `profileFetched: false`.

#### How accurate is the price and supplier data?

The Actor returns prices, scores and supplier fields exactly as Alibaba's search API and minisite return them at request time — nothing is recalculated or estimated. Alibaba quotes prices in the currency of the request's exit IP, which is why `priceCurrency` is read per row and why pinning a proxy country keeps prices consistent across runs.

#### How many listings can I get per run?

Set `limit` per search: `1`–`10000` stops after that many rows, and `0` keeps paginating until Alibaba stops returning new listings, capped at 30 pages per search. Page size is matched to what's left to fetch, so nothing is pulled and thrown away.

#### How do I target only suppliers Alibaba has actually assessed?

Turn on `keepOnlyAuditedSuppliers` together with `fetchSupplierProfiles`. This reads `companyHasPassAssessment` off each unique supplier's minisite and drops any row it couldn't verify, rather than trusting the `onlyVerifiedSuppliers` search filter alone — that filter narrows Alibaba's result set, but no field on the listing itself confirms verification.

#### Does Alibaba Listings Scraper & Supplier Profiles work with Claude, ChatGPT and AI agent frameworks?

It's callable as a standard HTTP endpoint through the Apify API, so any agent framework that can call a REST API and read JSON can call this Actor as a tool — start the run, poll or wait, then read the dataset back.

#### How does this compare to other Alibaba scrapers?

The real differentiator is the supplier minisite lookup: rather than inferring supplier trustworthiness from the search snippet, this Actor makes one cached request per unique supplier and reads Alibaba's own `companyHasPassAssessment` flag, tenure and paid-membership status directly, and marks the field `null` with a note when it can't confirm it — instead of leaving the field blank with no explanation.

#### Can I use this without an Alibaba account or API key?

Yes. No Alibaba login, account or API key is needed — you only need an Apify account to run the Actor and read the dataset back.

***

### Conclusion

Alibaba Listings Scraper & Supplier Profiles turns a keyword or search URL into structured listing rows with the supplier's identity, scores and — optionally — its real audited status and tenure attached to every one. It's built for sourcing teams, vetting agencies and pricing analysts who need to filter a huge catalogue down to suppliers actually worth contacting, without guessing at verification status from a search snippet. Every field ships as typed JSON with a stable schema, ready to run today on Apify.

# Actor input Schema

## `urls` (type: `array`):

One entry per line.

• Keyword — e.g. cnc machining parts
• Full URL — e.g. https://www.alibaba.com/trade/search?SearchText=led%20grow%20light\&country=US\&moqt=5

When you paste a URL, its filters are re-sent to Alibaba and its page number is used as the starting page.

## `limit` (type: `integer`):

How many listings to keep for each keyword/URL.

• 0 = keep going until Alibaba stops returning new listings (capped at 30 pages per search)
• 1–10000 = stop after this many

Only the rows you asked for are requested — the page size is matched to what is left, so nothing is fetched and thrown away.

## `fetchSupplierProfiles` (type: `boolean`):

Adds isAudited (the platform's real assessment flag), yearsOnAlibaba and isPaidMember.

Cost: exactly one request per UNIQUE supplier, cached for the whole run. Minisite pages are large (168 KB – 1.1 MB), so a run over hundreds of distinct suppliers takes noticeably longer.

When a minisite cannot be read, the three fields stay null and profileFetched is false — nothing is ever guessed.

## `maxSupplierProfiles` (type: `integer`):

Hard cap on minisite requests for the whole run. Suppliers past the cap still ship their listing row with profileFetched = false.

## `oneRowPerSupplier` (type: `boolean`):

Collapse the results into a supplier list: one row per company, keeping its first listing, with listingsFromThisSupplier telling you how many of its listings matched. Collapsing happens before anything is saved.

## `keepOnlyAuditedSuppliers` (type: `boolean`):

Drop every row whose minisite does not say companyHasPassAssessment = true. Needs the minisite lookup above. Rows whose minisite could not be read are dropped rather than guessed, so this filter is strict by design.

## `onlyVerifiedSuppliers` (type: `boolean`):

Sends assessmentCompany=true and verifiedPro=1. Alibaba accepts both and narrows the result set, but no listing field states verification status — with the minisite lookup on, the run logs how many of the returned suppliers really carry the audited flag.

## `minSupplierRating` (type: `string`):

Sends Alibaba's store\_reviews filter. Suppliers without a rating are excluded by Alibaba when this is set.

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

This setting is actually used: turn it off and no proxy is used; pick a group or country and that is what the requests go through.

Residential + US is the default because it gives USD prices and the cleanest access.

## `autoEscalateWhenBlocked` (type: `boolean`):

Alibaba answers a blocked request with HTTP 200 and a JSON punish body. When that happens, retry the same request through Apify Proxy (direct → datacenter → residential) even if the proxy above is off. Turn this off to keep a run strictly on the network you chose.

## Actor input object example

```json
{
  "urls": [
    "https://www.alibaba.com/trade/search?SearchText=samsung%20galaxy&page=1"
  ],
  "limit": 10,
  "fetchSupplierProfiles": true,
  "maxSupplierProfiles": 25,
  "oneRowPerSupplier": false,
  "keepOnlyAuditedSuppliers": false,
  "onlyVerifiedSuppliers": false,
  "minSupplierRating": "any",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "autoEscalateWhenBlocked": true
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

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

Per-search results, totals and settings applied, written once to the default key-value store.

# 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 = {
    "urls": [
        "https://www.alibaba.com/trade/search?SearchText=samsung%20galaxy&page=1"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "urls": ["https://www.alibaba.com/trade/search?SearchText=samsung%20galaxy&page=1"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/alibaba-listings-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 '{
  "urls": [
    "https://www.alibaba.com/trade/search?SearchText=samsung%20galaxy&page=1"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call simpleapi/alibaba-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simpleapi/alibaba-listings-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/1jkySlpLB5pd6fc3z/builds/c80iPiIvY2KvCGWME/openapi.json