# Alibaba Supplier Finder (`apt_marble/alibaba-supplier-finder`) Actor

Find Alibaba manufacturers and trading companies by keyword, category and country. One row per company, never one per listing: verification status, years on the marketplace, buyer rating, order history, trade volume, response speed, plus a sample product with its price and minimum order.

- **URL**: https://apify.com/apt\_marble/alibaba-supplier-finder.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$7.00 / 1,000 supplier founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Alibaba Supplier Finder

Build a qualified list of Alibaba manufacturers and trading companies from a
keyword, a category, a country, or all three at once. You get **one row per
company** — not one row per product listing — with the company's credentials,
its trade record, how fast it replies, and a sample of what it sells at what
price and what minimum order. Every row carries a link straight to that
supplier's own storefront, so a shortlist can go from search to outreach in a
single step.

This is the front half of a sourcing workflow: find the companies worth
talking to, then contact them.

***

### What you can do with it

- **Build a sourcing shortlist.** "Bluetooth speaker suppliers in China, verified,
  at least five years on the marketplace, rated 4.5 or better" — as a spreadsheet.
- **Find alternatives to your current factory.** Browse the exact category your
  product sits in and collect every company selling into it.
- **Source from a specific country.** Filter to India, Vietnam, Türkiye, the US
  or anywhere else, and see who actually manufactures there.
- **Qualify before you write.** Years on the marketplace, verification status,
  buyer rating, response speed, on-time delivery, order history and trade volume
  band are all on the row, so you can rank suppliers before spending a minute
  on outreach.
- **See the published category leaders.** Pull the marketplace's own list of
  leading factories for a category, in rank order.
- **Feed a CRM.** Each company appears exactly once, with a stable company id,
  so imports do not create duplicates.

***

### What you get

One row per company. Abridged real example:

```json
{
  "companyId": "235081922",
  "companyName": "Shenzhen Bogoodwill Industrial Co., Limited.",
  "countryCode": "CN",
  "country": "China",
  "minisiteUrl": "https://bogoodwill.en.alibaba.com/",
  "productsUrl": "https://bogoodwill.en.alibaba.com/productlist…",
  "ownerMemberId": "cn1522703336igbc",
  "goldSupplier": true,
  "supplierYears": 12,
  "verifiedSupplier": true,
  "verifiedProSupplier": false,
  "inspectionProvider": "Intertek",
  "transactionLevel": 7,
  "historicOrderCount": 1224,
  "historicTransactionValueText": "$2,300,000+",
  "historicTransactionValueCurrency": "USD",
  "recentOrderCount": 56,
  "recentOrderValueText": "30,000+",
  "recentOrderValueCurrency": "USD",
  "responseRate": "96.6%",
  "storeReviewScore": 4.3,
  "storeReviewCount": 25,
  "employees": 60,
  "factoryAreaSqm": 2000,
  "exportMarkets": ["Argentina", "Australia", "Brazil", "France", "Japan",
                    "South Korea", "Mexico", "Netherlands", "United States"],
  "mainProducts": "Bluetooth Speaker, TWS Earphone, Headphone",
  "sampleProduct": {
    "productId": "1601637345455",
    "title": "Portable Fabric 8W Outdoor Bluetooth Speaker Waterproof Support TF Card AUX TWS",
    "url": "https://www.alibaba.com/product-detail/Portable-Fabric-8W-Outdoor-Bluetooth-Speaker_1601637345455…",
    "priceMin": 2.8,
    "priceMax": 3.2,
    "currency": "USD",
    "priceHidden": false,
    "minOrderQuantity": 100,
    "minOrderUnit": "pieces"
  },
  "listingsSeen": 1,
  "foundBy": ["directory"],
  "foundByKeyword": "bluetooth speaker",
  "scrapedAt": "2026-08-10T09:14:22.104Z"
}
```

***

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `keywords` | list of text | `["bluetooth speaker"]` | What the suppliers should make or sell. Each keyword searches the whole marketplace for companies. |
| `categoryIds` | list of text | `[]` | Numeric category ids to browse. A full category address is accepted and the id is taken from it. |
| `supplierCountries` | list of text | `[]` | Two-letter codes of the countries the suppliers must be based in, e.g. `CN`, `IN`, `VN`, `TR`, `US`. Empty means anywhere. |
| `country` | select | `United States (USD)` | Which country's version of the marketplace you are buying from. It decides the currency prices are quoted in. Every row also states the currency its own figures came back in. |
| `maxSuppliers` | integer | `200` | How many distinct companies to return in total. Maximum 5,000. |
| `maxPagesPerTarget` | integer | `10` | How deep to go into each search before moving on. Maximum 417. |
| `searchSupplierDirectory` | boolean | `true` | Use the company-first search. This is what keywords use, and the only place transaction level, order history and trade value come from. |
| `searchProductListings` | boolean | `true` | Browse a category's listings and collect the company behind each one. This is what category ids use. |
| `includeFactoryRankings` | boolean | `false` | Add the marketplace's published leading factories for each category id, with rank, six-month trade band, on-time delivery and response speed. |
| `verifiedOnly` | boolean | `false` | Keep only companies confirmed as inspected and verified. |
| `tradeAssuranceOnly` | boolean | `false` | Keep only companies offering the marketplace's own order protection. |
| `excludePromoted` | boolean | `false` | Drop companies found only through a promoted placement. |
| `minSupplierYears` | integer | — | Minimum years the company has held its paid membership. 0–30. |
| `minTransactionLevel` | integer | — | Minimum on the marketplace's own 0–10 business-volume scale. |
| `minStoreRating` | number | — | Minimum buyer rating out of 5. |
| `parallelReads` | integer | `1` | How many category searches to run at once. 1–3. |

**Keywords and category ids are not interchangeable, and the difference
matters.** A keyword on its own searches the whole marketplace. A category id
browses that category. A keyword *together with* a category id narrows that
category — so pairing a keyword with an unrelated category correctly returns
nothing rather than everything.

***

### Output fields

| Field | Type | Meaning |
| --- | --- | --- |
| `companyId` | text | Stable identifier for the company. One row per value, always. |
| `companyName` | text | Registered company name. |
| `countryCode` / `country` | text | Where the company is based. |
| `minisiteUrl` | link | The company's own storefront. |
| `productsUrl` | link | The company's product list, where published. |
| `ownerMemberId` / `memberId` / `loginId` | text | The company's account identifiers on the marketplace. |
| `goldSupplier` | boolean | Whether the company holds the paid membership tier. |
| `supplierYears` / `supplierYearsText` | number / text | How long it has held that membership. |
| `verifiedSupplier` / `verifiedProSupplier` | boolean | Whether an independent inspector has verified the company, and at which level. |
| `tradeAssurance` | boolean | Whether the company offers the marketplace's order protection. |
| `inspectionProvider` | text | Which inspection firm verified it. |
| `certifications` | list | Company certifications shown on its listings, e.g. `ISO`. |
| `badges` | list | Capability badges the marketplace shows, e.g. `ODM service available`. |
| `transactionLevel` | number | The marketplace's own 0–10 business-volume scale. |
| `starLevel` | number | The marketplace's own star tier. |
| `historicOrderCount` | number | Orders the company has completed. |
| `historicTransactionValueText` / `…From` / `…Currency` | text / number / text | All-time trade volume as a published band, the floor of that band, and the unit it is quoted in. |
| `recentOrderCount` | number | Recent completed orders. |
| `recentOrderValueText` / `…From` / `…Currency` | text / number / text | Recent trade volume band, its floor, and its unit. |
| `sixMonthTransactionValueText` / `…Currency` | text | Six-month trade volume band and its unit. From the factory rankings. |
| `responseRate` / `responseTime` | text | How often and how quickly the company replies to buyers. |
| `onTimeDeliveryRate` | text | Share of orders delivered on time. From the factory rankings. |
| `storeReviewScore` / `storeReviewCount` | number | The **company's** buyer rating and number of reviews. |
| `storeReviewCountText` | text | Set instead of the count when the marketplace publishes only a band such as `700+`. |
| `storeServiceScore` / `storeShippingScore` | number | Buyer ratings for service and for delivery. |
| `employees` / `employeesText` | number / text | Staff, exact where published and as a band where not. |
| `factoryAreaSqm` / `factoryAreaText` | number / text | Factory floor area, exact where published and as a band where not. |
| `exportMarkets` | list | Countries the company already exports to. |
| `mainProducts` | text | What the company says it makes. |
| `customizationAvailable` | boolean | Whether it accepts customisation. |
| `categoryRank` / `categoryRanked` | number / boolean | Position in the marketplace's published leaders list for the category, when there is one. |
| `isPromoted` | boolean | Whether the company was found through a promoted placement. |
| `sampleProduct` | object | One of the company's products: id, title, link, price range, currency, `priceHidden`, `promotionPriceText`, `isOnPromotion`, minimum order quantity and unit. |
| `listingsSeen` | number | How many of this company's listings were seen before the row was written. |
| `foundBy` | list | Which of the three views found it. |
| `foundByKeyword` / `foundByCategoryId` / `foundByCountry` | text | Which search found it first. |
| `scrapedAt` | text | When the row was collected. |

Every rating on a row belongs to the **company**, not to the sample product —
they are named `store…` throughout so the two can never be mixed up. Any figure
that the marketplace publishes only as a band (`$180,000+`, `700+`,
`15,000+ ㎡`) is kept as that band's own text field, and is never quietly turned
into an exact number — including one figure the marketplace dresses up with
decimal places that is a band underneath, which is left out altogether rather
than passed off as a measurement.

Every price carries the unit it was quoted in, written out as a currency code.
A figure whose unit the marketplace did not state is reported without one
rather than assumed, and the run counts how many of those there were.

***

### Pricing

Pay per result.

| What you pay for | Price |
| --- | --- |
| Supplier found | **$7.00 per 1,000** ($0.007 each) |

A company is charged **once**, no matter how many of its listings were seen
finding it. That matters more than it sounds: a single page of results routinely
contains several listings from the same factory, and a per-listing charge would
bill you many times for one lead. The run summary reports listings seen against
distinct companies found so you can always see the difference.

**Worked example.** A shortlist of 200 verified suppliers across three keywords
and two countries costs **$1.40**.

***

### Limits & what this actor cannot do

- The marketplace publishes a limited number of public results for any one
  search, category or country, so very large targets return what it makes
  available rather than an unlimited directory. There is no way to enumerate
  every company on the marketplace, and this actor does not claim to.
- A country filter narrows results sharply and legitimately. Some
  country-and-category combinations genuinely have only a handful of suppliers,
  and a small result is a real answer, not a failure.
- Verification status, transaction level, order history and trade volume come
  from the company-first search. A company found only by browsing a category's
  listings will have those fields empty — they are reported as unknown rather
  than guessed at. Keep **Search the supplier directory** switched on to fill
  them in.
- On-time delivery, response speed and the six-month trade band come from the
  factory rankings, which exist only for some categories. Where no ranking is
  published for a category, that is reported plainly and no substitute list is
  returned in its place.
- Trade volumes are published as bands (`$180,000+`), not as exact figures, and
  the band's floor is all that can honestly be read from it.
- **Order protection status is published only in the factory rankings.** Filtering
  on it while searching by keyword or by category therefore removes every
  company, because none of them state it — the run says so and tells you what to
  change. To use that filter, turn **Include factory rankings** on and give a
  category id.
- A quality filter never treats "not published" as a pass. A company whose
  verification, transaction level or rating the marketplace does not publish
  where it was found is removed, and the run reports how many each filter
  removed and why, so an empty result is never a mystery.
- Category browsing is capped at a fixed number of pages across the whole job to
  keep the marketplace responsive. A very large job spends that allowance on its
  earlier searches and reports the later ones as shortened rather than as
  finished.
- Review counts are sometimes published as bands too (`700+`). Those are kept as
  text rather than converted into a count.
- Some suppliers publish no price and invite buyers to ask for a quote. Those
  come back marked as price-on-enquiry, never as a zero price.
- Wholesale prices are the supplier's published asking price. The price actually
  agreed in a negotiated order is not published and is not returned.
- Contact details a supplier chooses not to publish are not returned. You get
  the storefront link, which is where enquiries go.
- Ratings, rankings, prices and trade volumes are a snapshot at the moment of
  collection and keep changing afterwards.
- Prices differ by country. Results reflect the version of the marketplace for
  the country you say you are buying from, and every row states the currency its
  own figures came back in. That control is separate from the supplier-country
  filter: one is where you are, the other is where the factory is.
- Promoted placements appear inside the marketplace's own results. They are
  flagged so you can keep or exclude them.
- Speed depends on the size of the job and on the marketplace's own response
  times; no fixed throughput is promised.
- The marketplace's terms govern automated access. You are responsible for using
  the data lawfully and in line with those terms, and for handling any personal
  data in line with applicable privacy law.

***

### FAQ

**Do I need an account on the marketplace?**
No. Nothing is logged into and no account is used.

**Does it need my login or password?**
No, and it never asks for one.

**Can I schedule it?**
Yes. Schedule it on Apify like any other actor — a weekly sweep of your
categories is a good way to spot new factories entering your market.

**Is the data complete?**
It is complete as far as the marketplace publishes it publicly. Any one search
returns a limited public set, so treat the output as a strong sample of the
supplier base rather than a full census. Running several keywords, categories
and countries in one job and letting the actor merge them is the way to widen
coverage — companies found more than once still cost you one row.

**Why does one company sometimes show `listingsSeen: 9`?**
Because that factory had nine products in the results. You are billed once and
get one row; the count is there so you can see how prominent the company is.

**Can I get each supplier's full company profile?**
Not from this actor. This one finds and qualifies companies. Each row carries
the storefront link, which is exactly what a deep company-profile step needs as
its input.

**I turned on a quality filter and got nothing back. Why?**
Because the marketplace does not publish that status for the companies these
searches found, and an unknown is never counted as a yes. The run names the
filter, says how many companies it removed and tells you what to change — most
often, keeping the supplier directory switched on, or adding a category id and
the factory rankings.

**Why is `verifiedSupplier` empty for some companies?**
Because they were found by browsing a category's listings, which do not state
verification either way. An empty value means unknown, not "not verified". Turn
on **Search the supplier directory** to have it filled in.

# Actor input Schema

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

What the suppliers you want should make or sell, for example "bluetooth speaker". Each keyword searches the whole site for companies. Add a category id below to search inside one category instead.

## `categoryIds` (type: `array`):

Numeric category ids to browse, for example 201189203. You can paste a full category address and the id will be taken from it. Leave empty to search by keyword only.

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

Two-letter codes of the countries the suppliers should be based in, for example CN, IN, VN, TR, US. Leave empty for suppliers anywhere.

## `country` (type: `string`):

Which country's version of the marketplace to read. It decides the currency prices are quoted in. Every row also states the currency its own figures came back in, so you always know what a number means.

## `maxSuppliers` (type: `integer`):

How many distinct companies to return in total. Companies are counted once each, however many of their listings appear.

## `maxPagesPerTarget` (type: `integer`):

How deep to go into each search before moving on. More pages find more companies but take longer.

## `searchSupplierDirectory` (type: `boolean`):

The company-first search. This is what keywords use, and it is the only place transaction level, historic order count and historic trade value come from. Turn it off only if you are browsing categories alone.

## `searchProductListings` (type: `boolean`):

Browse a category's listings and collect the company behind each one. This is what category ids use, and it is the source that honours the supplier-country filter most precisely.

## `includeFactoryRankings` (type: `boolean`):

Add the site's published leading factories for each category id, with their rank, six-month trade band, on-time delivery rate and response time. Not every category has a published ranking.

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

Keep only companies confirmed as inspected and verified. Verification status is only known for companies found through the supplier directory or the factory rankings, and a company whose status is not published is removed rather than assumed to be verified.

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

Keep only companies that offer the site's own order protection. Read this one carefully: order-protection status is published ONLY in the factory rankings, so switching this on without also switching on Include factory rankings (with a category id) removes every company found. The run says so plainly when it happens.

## `excludePromoted` (type: `boolean`):

Drop companies that were found only through a paid placement in the results.

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

Keep only companies that have held their paid membership for at least this many years.

## `minTransactionLevel` (type: `integer`):

The site's own 0 to 10 scale for how much business a company has done. Only known for companies found through the supplier directory.

## `minStoreRating` (type: `number`):

Keep only companies rated at least this highly by their buyers, out of 5. Companies with no rating yet are not kept when this is set.

## `parallelReads` (type: `integer`):

How many category searches to run at once. One is the gentlest on the source and the most reliable; three is the most this actor will do.

## Actor input object example

```json
{
  "keywords": [
    "bluetooth speaker"
  ],
  "categoryIds": [],
  "supplierCountries": [],
  "country": "us",
  "maxSuppliers": 100,
  "maxPagesPerTarget": 10,
  "searchSupplierDirectory": true,
  "searchProductListings": true,
  "includeFactoryRankings": false,
  "verifiedOnly": false,
  "tradeAssuranceOnly": false,
  "excludePromoted": false,
  "parallelReads": 1
}
```

# Actor output Schema

## `suppliers` (type: `string`):

One row per company found in this run, with credentials, trade record and a sample product.

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

Listings seen against distinct companies found, plus the outcome of every search including any that could not be read.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "bluetooth speaker"
    ],
    "categoryIds": [],
    "supplierCountries": [],
    "country": "us",
    "maxSuppliers": 100,
    "maxPagesPerTarget": 10,
    "parallelReads": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/alibaba-supplier-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["bluetooth speaker"],
    "categoryIds": [],
    "supplierCountries": [],
    "country": "us",
    "maxSuppliers": 100,
    "maxPagesPerTarget": 10,
    "parallelReads": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/alibaba-supplier-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "bluetooth speaker"
  ],
  "categoryIds": [],
  "supplierCountries": [],
  "country": "us",
  "maxSuppliers": 100,
  "maxPagesPerTarget": 10,
  "parallelReads": 1
}' |
apify call apt_marble/alibaba-supplier-finder --silent --output-dataset

```

## MCP server setup

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

```

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/h0RkAwTlFTcTAGBrP/builds/P0AiYSGYmvQ5wIXQd/openapi.json