# Alibaba Email Scraper (`w3crawler/alibaba-email-scraper`) Actor

Extract publicly indexed Alibaba seller emails from Google search results and public profile pages.

- **URL**: https://apify.com/w3crawler/alibaba-email-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 supplier emails

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?

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

### What does Alibaba Email Scraper do?

Alibaba Email Scraper finds email addresses that are visibly published alongside supplier content on [Alibaba.com](https://www.alibaba.com/) and public Google result pages. It returns a rich, normalized supplier record for each public email, including the supplier identity, tenure, badges, products, country, revenue range, markets, tags, response rate, source page, and pagination position.

This Actor is a public-source extractor. It does not sign in, open private contact details, solve CAPTCHAs, call private APIs, bypass access controls, or invent missing values. A public email is emitted only when it can be associated with permitted Alibaba content. Google account or unrelated page emails are not treated as supplier contacts.

### Why use Alibaba Email Scraper?

Use it to build a public supplier prospecting list, discover Alibaba manufacturers by keyword, enrich an existing supplier search with structured company facts, or run recurring public-source monitoring through the Apify API, schedules, integrations, and run history.

Supported features include:

- Public Google site searches and direct Alibaba supplier/company/product URLs.
- Rich supplier-card extraction based on the observed Alibaba supplier-list markup.
- Up to 100 pages per source, next-link detection, safe pagination fallbacks, and repeated-page guards.
- Multiple sources, global contact limits, email deduplication, case-insensitive filters, and global sorting.
- Bounded product arrays, optional tags and context snippets, transparent retries, pacing, concurrency, request timeouts, and standard Apify Proxy routing.
- Operational issue counts and detailed run counters in `OUTPUT_SUMMARY`, with failure details in run logs; the dataset contains only source-backed supplier contacts.

### What data can Alibaba Email Scraper extract?

| Field | Type | Description |
| --- | --- | --- |
| `email`, `emailDomain` | string | Public email and normalized lowercase domain. |
| `supplierName`, `company` | string | Observed supplier/company name; `company` is a compatibility alias. |
| `supplierProfileUrl` | URL | Public Alibaba company profile when available. |
| `supplierYears`, `supplierYearsText` | integer/string | Supplier tenure shown on the card. |
| `badges`, `isGoldSupplier`, `hasTradeAssurance` | array/boolean | Observed supplier badges and badge flags. |
| `listingTitle`, `products`, `productUrls`, `productCount` | string/array/integer | Product titles and product-detail URLs shown on the card; supplier/company profile links are never counted as products. |
| `country`, `mainProducts`, `mainProductsList` | string/array | Observed supplier location and product categories. |
| `totalRevenue`, `topMarkets`, `topMarketsText` | string/array | Public revenue and market information. |
| `tags`, `responseRate`, `responseRateText` | array/number/string | Supplier tags and response-rate information. |
| `sourceUrl`, `pageUrl`, `sourceType`, `query`, `pageNum`, `position` | mixed | Search provenance and page position. |
| `contextSnippet`, `pageTitle`, `listingPrice`, `scrapedAt` | mixed | Bounded public context and timestamps. |

Fields are omitted when the source does not publish them. Run metrics such as request counts, retries, proxy state, and issue counts are kept in `OUTPUT_SUMMARY` and `SOURCE_METADATA`, not added as debugging columns to normal contact rows. Failure details stay in run logs.

### How to scrape Alibaba supplier emails

1. Open the Actor and choose a public Alibaba supplier URL, or enter a search `query` such as `stainless steel bottle supplier`.
2. Use `startUrls` for one or more public Google/Alibaba pages, or `profileUrls` for direct Alibaba sources. Explicit URLs take precedence over generated Google searches.
3. Set filters, sorting, pagination, and dataset detail controls if needed.
4. Run the Actor. Open the dataset for contacts and the key-value store for `OUTPUT_SUMMARY` and `SOURCE_METADATA`.

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

The cost depends on the compute time used by the run and the limits you choose. More source URLs, pages, retries, larger response limits, and higher concurrency can increase compute. Global sorting may fetch every permitted page before selecting the top contacts. Product arrays and context snippets increase dataset size but do not create separate detail-page requests. Use `maxPages`, `maxResults`, `maxProductsPerResult`, a respectful delay, and conservative retries to control run size. Check the current Apify pricing and the run usage panel for account-specific costs.

### Input

See the input tab for the complete configuration. All values are validated before requests are made.

#### Search configuration and input sources

- `query` — string, default `industrial supplier`; the generated Google site-search keyword.
- `queries` — up to 20 search strings. Generated searches are used only when explicit source URLs are absent.
- `profileUrls` — up to 50 public Alibaba source URLs.
- `startUrls` — up to 50 objects in the form `{ "url": "https://www.alibaba.com/..." }`; public Google and Alibaba URLs are accepted.

#### Result filters and sorting

- `emailDomains` — optional domains such as `supplier.example`; subdomains also match.
- `textQuery` — case-insensitive match across supplier, product, country, badges, tags, markets, revenue, email, and context text.
- `supplierCountry` — exact case-insensitive Country/Region value, such as `China`.
- `minSupplierYears` — 0–200; missing tenure does not pass an active filter.
- `minResponseRate` — 0–100; missing response rate does not pass an active filter.
- `requiredBadges` — every requested badge must be observed.
- `sortBy` — `relevance`, `supplier_years_desc`, `response_rate_desc`, `company_asc`, `country_asc`, or `email_asc`.

#### Pagination and dataset controls

- `maxResults` — global contact limit, 1–500, default `50`.
- `maxPages` — pages per source, 0–100, default `1`; `0` means automatic pagination up to 100 pages.
- `deduplicate` — default `true`; merges repeated observations by normalized email.
- `maxEmailsPerResult` — maximum email-bearing rows considered from one source response, 1–20, default `5`.
- `includeProducts` — default `true`; includes product objects and product URLs.
- `maxProductsPerResult` — 0–10, default `5`; `0` omits product arrays while retaining an observed count.
- `includeTags` — default `true`.
- `includeContext` — default `true`; includes an exact-match public email context snippet.

#### Developer options

- `requestDelayMs` — 0–10,000 ms between public request starts, default `250`.
- `maxConcurrency` — 1–5 source URLs concurrently, default `2`; pagination within one source remains sequential.
- `maxRequestRetries` — 0–5 finite retries for transient failures, default `2`.
- `requestTimeoutSecs` — 5–120 seconds per request, default `30`.
- `maxResponseBytes` — 100,000–30,000,000 byte response safety cap, default `20,000,000`.
- `proxyConfiguration` — optional standard Apify Proxy settings. When `useApifyProxy` is `true`, permitted requests use Apify Proxy; proxying is not an access-control bypass. `timeoutMs` remains as a backwards-compatible millisecond alias.
- `userAgent` — optional transparent single-line user agent.

Checked-in HTML fixtures are used by the local parser tests to cover ordered pagination and multiple-source processing without network access. Fixture overrides are not public Actor inputs.

### Input examples

#### Quick smoke test

```json
{
  "query": "stainless steel bottle supplier",
  "maxResults": 10,
  "maxPages": 1
}
```

#### Filters and global sorting

```json
{
  "queries": ["industrial control module supplier"],
  "textQuery": "industrial",
  "minSupplierYears": 5,
  "minResponseRate": 70,
  "requiredBadges": ["Gold Supplier"],
  "sortBy": "response_rate_desc",
  "maxResults": 25,
  "maxPages": 2
}
```

#### Direct paginated Alibaba source

```json
{
  "profileUrls": ["https://www.alibaba.com/gmail.com-suppliers.html"],
  "maxResults": 100,
  "maxPages": 3,
  "deduplicate": true,
  "includeProducts": true,
  "maxProductsPerResult": 5
}
```

#### Multiple source URLs

```json
{
  "startUrls": [
    { "url": "https://www.alibaba.com/gmail.com-suppliers.html" },
    { "url": "https://www.alibaba.com/control-module-suppliers.html" }
  ],
  "maxResults": 50,
  "maxPages": 2,
  "deduplicate": true,
  "sortBy": "company_asc"
}
```

#### Detail opt-out

```json
{
  "profileUrls": ["https://www.alibaba.com/gmail.com-suppliers.html"],
  "maxResults": 25,
  "includeProducts": false,
  "maxProductsPerResult": 0,
  "includeTags": false,
  "includeContext": false
}
```

#### Developer options

```json
{
  "profileUrls": ["https://www.alibaba.com/gmail.com-suppliers.html"],
  "maxResults": 10,
  "maxPages": 1,
  "requestDelayMs": 500,
  "maxConcurrency": 1,
  "maxRequestRetries": 1,
  "requestTimeoutSecs": 45,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

#### Deterministic local pagination QA

```json
{
  "profileUrls": [
    "https://www.alibaba.com/gmail.com-suppliers.html"
  ],
  "maxPages": 2,
  "maxResults": 10,
  "requestDelayMs": 0,
  "maxConcurrency": 1,
  "maxRequestRetries": 0
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Rich contact record

The following is a shortened, anonymized example; product and market arrays are bounded by the input controls.

`productUrl`, `productUrls`, `products`, and `productCount` describe only observed Alibaba product-detail links. If a public email is associated with a supplier/company profile but no product link is visible, the profile is kept in `supplierProfileUrl`/`profileUrls` and the product fields remain absent.

```json
{
  "email": "sales@acme.test",
  "emailDomain": "acme.test",
  "supplierName": "Acme Industrial Co., Ltd.",
  "supplierProfileUrl": "https://acme.en.alibaba.com/company_profile.html",
  "supplierYears": 5,
  "supplierYearsText": "5 YRS",
  "isGoldSupplier": true,
  "hasTradeAssurance": true,
  "badges": ["Gold Supplier", "Trade Assurance"],
  "listingTitle": "Stainless Steel Bottle",
  "company": "Acme Industrial Co., Ltd.",
  "country": "China",
  "mainProducts": "Bottle,Travel Mug,Flask",
  "mainProductsList": ["Bottle", "Travel Mug", "Flask"],
  "totalRevenue": "US$5 Million - US$10 Million",
  "topMarkets": ["North America 60%", "Western Europe 25%"],
  "topMarketsText": "North America 60%, Western Europe 25%, Oceania 10%",
  "tags": ["Bottle Supplier", "Travel Mug Supplier"],
  "responseRate": 85,
  "responseRateText": "85% Response Rate",
  "productCount": 2,
  "products": [
    { "title": "Stainless Steel Bottle", "url": "https://www.alibaba.com/product-detail/Stainless-Steel-Bottle_100000001.html" }
  ],
  "productUrls": ["https://www.alibaba.com/product-detail/Stainless-Steel-Bottle_100000001.html"],
  "productUrl": "https://www.alibaba.com/product-detail/Stainless-Steel-Bottle_100000001.html",
  "profileUrls": ["https://acme.en.alibaba.com/company_profile.html"],
  "sourceType": "alibaba_supplier_search",
  "query": "gmail.com",
  "pageNum": 1,
  "position": 1,
  "sourceUrl": "https://www.alibaba.com/gmail.com-suppliers.html",
  "pageUrl": "https://www.alibaba.com/gmail.com-suppliers.html",
  "contextSnippet": "Acme Industrial Co., Ltd. sales@acme.test public supplier contact",
  "pageTitle": "Industrial supplier results",
  "listingPrice": "US$10.00",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

The dataset contains only source-backed supplier contacts. Inspect `OUTPUT_SUMMARY` for operational issue counts and the run logs for failure details.

#### Key-value run summary

```json
{
  "status": "SUCCEEDED",
  "runStatus": "SUCCEEDED",
  "dataStatus": "COMPLETE",
  "contactCount": 2,
  "diagnosticCount": 0,
  "recordsEmitted": 2,
  "requests": 2,
  "retries": 0,
  "successfulRequests": 2,
  "failedRequests": 0,
  "sourcesProcessed": 1,
  "pagesProcessed": 2,
  "candidatesFound": 2,
  "filteredOutCount": 0,
  "completedAt": "2026-01-01T00:00:00.000Z"
}
```

The `OUTPUT`, `OUTPUT_SUMMARY`, and `SOURCE_METADATA` keys are available in the run's default key-value store. Normal contact rows never include `fieldCoverage`, `dataQuality`, `httpStatus`, proxy credentials, or other Actor-debugging wrappers.

### Tips and advanced options

Start with one direct Alibaba supplier-search URL and `maxPages: 1` to inspect the source. Increase `maxPages` only when the first page is usable. Filters are applied page by page, but a page with no matches does not stop allowed pagination. Non-`relevance` sorting collects the permitted candidate set across pages before selecting the global top contacts, so it may use more requests. Missing numeric values fail active minimum filters and sort after observed values. A blocked response increments the operational issue count; details stay in run logs, and the Actor does not retry a challenge indefinitely.

### FAQ, support, and responsible use

**Why is the dataset empty?** Check `OUTPUT_SUMMARY` and the run logs. The source may have returned no public emails, a JavaScript challenge, a rate limit, an unsupported response, or a redirect outside the permitted host family.

**Can I use a private supplier contact page?** No. Only content already visible on permitted public Google/Alibaba responses is in scope.

**How do I report a problem?** Use the Actor's Issues tab and include the run ID, sanitized input, error code, and the relevant summary. The API tab exposes the dataset and key-value records for integrations.

Our Actors are ethical and do not extract private user data. Results can still contain personal data when someone has chosen to publish an address publicly. Follow Alibaba's and Google's terms, robots guidance, rate limits, applicable privacy law, and your legitimate-interest requirements. Consult qualified legal counsel when unsure. This Actor is not affiliated with Alibaba or Google.

Run summaries include the required `status`, `runStatus`, and `dataStatus` fields. `status` and `runStatus` are `SUCCEEDED` when source-backed rows were saved or a run completed cleanly with no matches; they are `FAILED` only when a real failure occurs before any rows are saved. `dataStatus` is `COMPLETE`, `PARTIAL`, `NO_RESULTS`, or `FAILED`. Failure details stay in the run logs; key-value summaries retain counts only.

# Actor input Schema

## `query` (type: `string`):

Supplier keyword used to build a public Google site search when no explicit startUrls or profileUrls are provided.

## `queries` (type: `array`):

Optional supplier keywords. Each becomes a public Google site:alibaba.com source; explicit startUrls/profileUrls take precedence over generated searches.

## `profileUrls` (type: `array`):

Optional public Alibaba supplier-search, company-profile, supplier-index, or product URLs. These are combined with startUrls and suppress generated Google searches.

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

Optional Google or Alibaba URLs in request-list form. URLs are deduplicated, paginated per source, and share one global maxResults limit.

## `emailDomains` (type: `array`):

Optional lowercase or @-prefixed domains. A contact passes when its domain equals a value or is a subdomain of it.

## `textQuery` (type: `string`):

Optional case-insensitive text match across email, supplier, company, product, country, badges, tags, markets, revenue, and context fields. Missing text does not match.

## `supplierCountry` (type: `string`):

Optional case-insensitive exact match against the observed Country/Region value, such as China or Vietnam.

## `minSupplierYears` (type: `number`):

Keep only records with an observed supplier tenure at or above this value. Records without a tenure value do not pass.

## `minResponseRate` (type: `number`):

Keep only records with an observed response rate at or above this percentage. Records without a response rate do not pass.

## `requiredBadges` (type: `array`):

Keep records whose observed badge list contains every requested value, case-insensitively, such as Gold Supplier or Trade Assurance.

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

Relevance keeps source/page/card order. Other choices sort globally after all permitted pages are fetched; missing numeric values sort last and text ties are stable.

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

Global maximum number of unique email-bearing contact records emitted across every source and page.

## `maxPages` (type: `integer`):

Maximum pages followed for each source URL. Use 0 for automatic pagination up to the hard 100-page safety cap.

## `deduplicate` (type: `boolean`):

Merge repeated public observations globally by normalized email across pages and sources.

## `maxEmailsPerResult` (type: `integer`):

Maximum parsed email-bearing rows considered from each response before filters. The global maxResults limit still applies.

## `includeProducts` (type: `boolean`):

Include observed product title/URL pairs and productUrls. The first productUrl remains available as the primary URL when present.

## `maxProductsPerResult` (type: `integer`):

Maximum product title/URL pairs retained per contact. Use 0 to omit product arrays while retaining the observed product count.

## `includeTags` (type: `boolean`):

Keep the bounded Tags list observed on supplier cards.

## `includeContext` (type: `boolean`):

Keep a bounded public contextSnippet around each normalized email. When enabled, the snippet contains the exact email.

## `requestDelayMs` (type: `integer`):

Minimum delay between starts of public requests. Use respectful pacing for live sources.

## `maxConcurrency` (type: `integer`):

Maximum number of source URLs processed concurrently. Pagination within one source stays sequential.

## `maxRequestRetries` (type: `integer`):

Finite retries for transient network, timeout, 408, 425, 429, and 5xx responses. Challenge and access-denied pages fail closed.

## `requestTimeoutSecs` (type: `integer`):

Maximum time allowed for one public response.

## `maxResponseBytes` (type: `integer`):

Safety cap for one HTML or JSON response.

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

Optional standard Apify Proxy route for permitted public requests. Proxying never bypasses robots, login, CAPTCHA, or access controls.

## `userAgent` (type: `string`):

Optional transparent single-line HTTP user-agent string.

## `timeoutMs` (type: `integer`):

Backward-compatible alias for requestTimeoutSecs. Prefer requestTimeoutSecs in new inputs.

## Actor input object example

```json
{
  "query": "industrial supplier",
  "requiredBadges": [],
  "sortBy": "relevance",
  "maxResults": 50,
  "maxPages": 1,
  "deduplicate": true,
  "maxEmailsPerResult": 5,
  "includeProducts": true,
  "maxProductsPerResult": 5,
  "includeTags": true,
  "includeContext": true,
  "requestDelayMs": 250,
  "maxConcurrency": 2,
  "maxRequestRetries": 2,
  "requestTimeoutSecs": 30,
  "maxResponseBytes": 20000000
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `sourceMetadata` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/alibaba-email-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/alibaba-email-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 '{}' |
apify call w3crawler/alibaba-email-scraper --silent --output-dataset

```

## MCP server setup

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