# Alibaba Email Scraper: Top Supplier Leads (`scraper-engine/alibaba-email-scraper`) Actor

Alibaba Email Scraper extracts publicly available email addresses from Alibaba supplier and company pages. Build targeted contact lists for sourcing, negotiations, and direct manufacturer outreach at scale.

- **URL**: https://apify.com/scraper-engine/alibaba-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## 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 Email Scraper — Emails, Domains and Patterns

Alibaba Supplier Email Scraper finds business email addresses tied to Alibaba.com supplier listings and returns them as structured JSON. Every row carries the extracted `email`, its `emailDomain`, a `hasBusinessEmail` flag that separates corporate addresses from free-mail accounts, and the search `emailPattern` that surfaced it. No manual searching, no copy-pasting from Google — [run the Actor](#how-to-use-alibaba-supplier-email-scraper) and stream ready-to-use leads straight to your dataset.

### What is Alibaba Supplier Email Scraper?

Alibaba Supplier Email Scraper is an Apify Actor that runs Google `site:alibaba.com` searches against a library of business-email query patterns (contact addresses, careers/HR, customer service, business development, and more), then parses the results for corporate emails, classifies them, and deduplicates across every pattern and keyword. It does not log into Alibaba or use an Alibaba account — it queries Google's public search results through an Apify proxy, so no Alibaba credentials are required. It's built for sourcing teams, sales/BD reps, and lead-gen developers who need a list of supplier contact emails for a product or industry niche without browsing Alibaba by hand.

### What Alibaba supplier email data is publicly available to scrape?

Alibaba pages indexed by Google expose page titles, snippets, and any email a supplier has published on their listing — this Actor extracts exactly that, nothing more.

| Data Category | Publicly Available | Restricted behind Alibaba's inquiry form |
| --- | --- | --- |
| Page title & snippet | Yes | — |
| Emails published on the page | Yes, when listed | — |
| "Contact Supplier" buyer messaging | No | Alibaba login + inquiry form |
| TrustPass/verified supplier reports | No | Paid Alibaba verification |
| Supplier phone/landline numbers | Not extracted by this Actor | Often behind login |
| Bulk pricing/quote negotiation | No | Direct supplier inquiry |

Alibaba Supplier Email Scraper only returns publicly visible data — what Google's index already shows. Nothing behind a login.

### What data can I extract with Alibaba Supplier Email Scraper?

The Actor returns one row per unique business email, with the query and email metadata that produced it.

| Field Name | Description |
| --- | --- |
| `network` | Source marketplace label, e.g. `Alibaba.com` (driven by the `supplierMarketplace` input). |
| `keyword` | The business keyword that produced this row. |
| `title` | Google search-result title for the matching page. |
| `description` | Google search-result snippet text for the matching page. |
| `url` | URL of the matching Alibaba page. |
| `mode` | Harvest mode used for the run: `standard` or `bulk`. |
| `emailPattern` | Name of the business-email search pattern that found this row (e.g. `contact_at_domain`, `careers_hiring`). |
| `matchedPattern` | The exact Google query string the email was matched from. |
| `email` | Extracted email address. |
| `emailDomain` | Host part of the email (e.g. `example-lighting.com`). |
| `hasBusinessEmail` | `true` when the email is a corporate address; `false` when it matches a free-mail suffix (gmail, yahoo, outlook, qq, 163, etc.). |
| `scrapedAt` | ISO-8601 UTC timestamp of when the row was collected. |

#### Result & source fields

`network`, `title`, `description`, `url`, `keyword` identify which page the email came from and what search produced it.

#### Pattern & harvest metadata

`mode`, `emailPattern`, `matchedPattern` show which of the ~29 business-email dork templates (or the ~6 curated Standard-mode subset) matched, and the literal query used.

#### Email & classification fields

`email`, `emailDomain`, `hasBusinessEmail`, `scrapedAt` give the contact itself, its domain, whether it's a business address, and when it was captured.

#### 🤖 Add-on: Need additional Alibaba/B2B data?

Pair this Actor with **[LinkedIn B2B Emails Scraper: Verified Email Finder](../linkedin-b2b-emails-scraper-verified-email-finder)** to pull company-domain-grouped emails from LinkedIn, or **[Instagram B2B Email Scraper](../Instagram-B-Two-B-Email-Scraper)** to prospect the same niche on Instagram with optional profile enrichment. For contact discovery across dozens of other sites in one Actor, **[Extract Emails, Contacts & Socials from Any Website](../extract-emails-contacts-socials-from-any-website)** runs the same Google-dork approach against Alibaba plus 70+ other platforms.

### Why not build this yourself?

Alibaba doesn't publish a self-serve developer API for supplier contact data, and Alibaba's own Open Platform API is a partner/business integration, not something you sign up for as an individual developer. Building this in-house means writing and maintaining Google SERP parsing (result markup changes without notice), managing rotating proxies to avoid IP blocks, engineering and tuning dozens of business-email search patterns, and handling classification/dedup logic yourself. Alibaba Supplier Email Scraper already does all of this — you supply keywords and get classified, deduplicated JSON rows back.

### How to use Alibaba Supplier Email Scraper

Run it directly from its Apify Store listing — no separate signup or Alibaba account needed.

1. Open the Actor's page in the Apify Console and click **Start**.
2. Add one or more terms to `businessKeywords` (e.g. `led lighting`, `stainless steel`) — this drives every search the Actor runs.
3. Optionally set `mode` to `bulk` for the full ~29 patterns per keyword, add a `region`, or cap results with `maxBusinessEmails`.
4. Start the run.
5. Download results as JSON or CSV from the run's dataset, or stream them via the Apify API.

#### How to scale to bulk Alibaba supplier email extraction

`businessKeywords` accepts an array, so one run already covers multiple keywords — each is expanded into its own set of search patterns automatically. To go further, switch `mode` to `bulk` (~29 patterns per keyword instead of ~6) and raise `maxBusinessEmails` and `maxEmailsPerPattern`. There's no separate "URL list" input; keywords are the bulk unit here.

### What can you do with Alibaba supplier email data?

- A sourcing manager researching a product category adds `led lighting` and `region: "Shenzhen"` to `businessKeywords`, then filters on `hasBusinessEmail` to build a corporate contact list before sending RFQs.
- A sales/BD rep uses `emailPattern` to see whether a lead surfaced from a `careers_hiring`, `business_development`, or `customer_service` query, and tailors the outreach message accordingly.
- A market researcher groups rows by `keyword` and `emailDomain` to map how many distinct supplier domains appear in a given niche.
- A dropshipping/import business runs multiple product keywords in one job and exports `email` + `url` as a prospecting list for wholesale outreach.
- An AI engineer feeds `title`, `description`, and `email` rows into an LLM agent that drafts personalized first-contact outreach emails per supplier, using the structured JSON directly as tool input with no HTML parsing step.

### How does Alibaba Supplier Email Scraper handle rate limits and blocking?

Every Google request routes through an Apify proxy group selected by the `engine` input — `legacy` uses the GOOGLE\_SERP group (Google-optimized IPs), `residential` uses the RESIDENTIAL group. Each request also randomizes its user agent and accept-language header and waits a randomized delay before firing. A response is only flagged as blocked when it's a non-200 status, or a small body carrying a literal block phrase (a large normal results page is never misflagged) — on a block or transport error, the Actor requests a fresh proxy IP and retries, up to 3 attempts per page. If a query still fails after retries, that one query is skipped (logged as a warning) and the run moves on to the next pattern or keyword rather than stopping. `maxRunSeconds` caps total wall-clock time so a run stops cleanly and streams whatever it already collected instead of being killed at the platform timeout.

### ⬇️ Input

All fields are optional — the Actor also requires at least one entry in `businessKeywords` at run time to collect any results.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `businessKeywords` | No | array | Product, industry, or company keywords to harvest supplier emails for. Each keyword is expanded into search patterns. | `["led lighting", "packaging"]` |
| `mode` | No | string | `standard` (~6 curated high-yield patterns per keyword, fast) or `bulk` (~29 patterns per keyword, max yield). Default `standard`. | `"bulk"` |
| `selectedPatterns` | No | array | Run only these pattern names instead of the mode default. Unknown names fail the run. | `["contact_at_domain", "careers_hiring"]` |
| `maxEmailsPerPattern` | No | integer | Cap on emails collected per pattern (1–500). Default 10. | `15` |
| `maxRunSeconds` | No | integer | Overall wall-clock budget (30–270). Default 235. | `235` |
| `excludeFreeMail` | No | boolean | Keep only business emails, dropping free-mail addresses. Default true. | `true` |
| `maxBusinessEmails` | No | integer | Total unique business emails to harvest across the whole run (1–5000). Default 20. | `100` |
| `region` | No | string | Optional country/city term added to every search. Default empty (global). | `"Shenzhen"` |
| `businessDomains` | No | array | Keep only emails ending in these domains. Default empty (keep all). | `[".com.cn"]` |
| `supplierMarketplace` | No | string | B2B marketplace driving the `site:` restriction and the `network` label. Currently `Alibaba`. | `"Alibaba"` |
| `engine` | No | string | Proxy group for Google requests: `legacy` (GOOGLE\_SERP) or `residential` (RESIDENTIAL). | `"legacy"` |
| `proxyConfiguration` | No | object | Apify proxy settings. | `{"useApifyProxy": false}` |

#### Example input

```json
{
  "businessKeywords": ["led lighting", "packaging"],
  "mode": "bulk",
  "selectedPatterns": [],
  "maxEmailsPerPattern": 15,
  "maxRunSeconds": 235,
  "excludeFreeMail": true,
  "maxBusinessEmails": 100,
  "region": "Shenzhen",
  "businessDomains": [],
  "supplierMarketplace": "Alibaba",
  "engine": "legacy",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### ⬆️ Output

Results are pushed as typed JSON rows with a consistent 12-field schema across every run, exportable as JSON, CSV, or Excel from the dataset.

#### Example output

```json
{
  "network": "Alibaba.com",
  "keyword": "led lighting",
  "title": "Example Lighting Co., Ltd. - Alibaba.com",
  "description": "LED lighting manufacturer, wholesale supplier. Contact us: info@example-lighting.com",
  "url": "https://www.alibaba.com/product-detail/example-lighting_123456.html",
  "mode": "bulk",
  "emailPattern": "contact_at_domain",
  "matchedPattern": "site:alibaba.com \"led lighting\" (\"contact@\" OR \"info@\" OR \"hello@\" OR \"team@\" OR \"support@\") -gmail -yahoo",
  "email": "info@example-lighting.com",
  "emailDomain": "example-lighting.com",
  "hasBusinessEmail": true,
  "scrapedAt": "2026-07-25T09:14:02Z"
}
```

### How does it work?

Alibaba Supplier Email Scraper doesn't browse Alibaba directly — it builds `site:alibaba.com` Google search queries from your keywords and a library of business-email query patterns, then fetches the results pages through an Apify proxy group (GOOGLE\_SERP or RESIDENTIAL, per the `engine` input) with rotating headers and jittered timing. Each results page is parsed for Alibaba links, and any email visible in the result's title or snippet is extracted, classified as business or free-mail, and deduplicated against every email already seen in the run. Only data already surfaced in Google's public search results is returned — nothing behind an Alibaba login. Because the output schema (`network`, `email`, `emailDomain`, `hasBusinessEmail`, etc.) is fixed by the Actor rather than scraped live from a page layout, it stays the same from run to run.

### Integrations

Alibaba Supplier Email Scraper runs on the Apify platform, so it works with the same API, SDKs, and automation tools as any other Apify Actor.

#### Calling Alibaba Supplier Email Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("<YOUR_USERNAME>/alibaba-email-scraper-top-supplier-leads").call(
    run_input={
        "businessKeywords": ["led lighting"],
        "mode": "standard",
        "maxBusinessEmails": 50,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["email"], item["hasBusinessEmail"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request to the Apify API.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node (or an HTTP Request node against the Apify run endpoint) configured with this Actor's ID and your API token to trigger runs and pull dataset items into your workflow. In Make, the Apify app's "Run Actor" module works the same way. Because output is plain typed JSON, it also drops directly into a LangChain document loader or custom tool without any HTML parsing step.

### Is it legal to scrape Alibaba supplier emails?

Scraping publicly visible data, such as business contact emails displayed in Google's indexed search results, is generally permitted; Alibaba Supplier Email Scraper only returns data already surfaced in public search results, nothing behind an Alibaba login. These are business/corporate contact addresses rather than personal accounts, so they are generally treated as less sensitive than personal data, but if a result includes an individual's name alongside their email, data-protection regimes like GDPR or CCPA can still apply to how you store and use it. Consult legal counsel if your use case involves bulk storage of personal data.

### Frequently asked questions

#### What Alibaba supplier email fields does Alibaba Supplier Email Scraper return?

The top fields are `email`, `emailDomain`, `hasBusinessEmail`, `emailPattern`, and `url` — see the [full fields table](#what-data-can-i-extract-with-alibaba-supplier-email-scraper) above for all 12.

#### Does Alibaba Supplier Email Scraper require an Alibaba account or login?

No. It queries Google's public search results through an Apify proxy and never logs into Alibaba, so no Alibaba credentials or session are needed.

#### How many supplier emails can I extract in one run?

Up to `maxBusinessEmails` (default 20, maximum 5000) per run, spread across every keyword and pattern, subject to the `maxRunSeconds` wall-clock budget.

#### What happens if a keyword returns zero results?

The Actor moves on to the next pattern or keyword rather than failing the run; if a query is blocked after 3 retries, that one query is skipped and logged as a warning. If no `businessKeywords` are supplied at all, the run logs an error and exits without collecting any rows.

#### Can I scrape multiple Alibaba supplier keywords at once?

Yes — `businessKeywords` accepts an array, and every keyword in the list is searched with the selected pattern set in the same run.

#### Does Alibaba Supplier Email Scraper work with Claude, ChatGPT, and other AI agent tools?

It doesn't run its own MCP server, but it's callable as a standard HTTP endpoint via the Apify API from any agent framework that can make a REST call — see [Integrations](#integrations) above.

#### How is "top supplier" determined?

It isn't computed by this Actor. The Actor's output has no ranking, rating, or supplier-verification field — every business email found by a matching pattern is returned. "Top" in the title reflects the aim of surfacing corporate/decision-maker contacts rather than a scored ranking, and that's a genuine limitation worth knowing before you rely on the results for supplier prioritization.

#### Does Alibaba Supplier Email Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors needed. Pass rows directly to an LLM prompt, index them into a vector store, or feed them to an agent tool.

#### What happens when Google or Alibaba changes its page layout?

The Actor is maintained and its output schema is designed to stay stable across runs; no specific update turnaround is published or promised.

#### Can I use Alibaba Supplier Email Scraper without managing proxies or browser infrastructure?

Yes — proxy selection (GOOGLE\_SERP or RESIDENTIAL group), IP rotation on a block, and retry logic are all handled internally via the `engine` input; you don't need to supply or manage your own proxies unless you want to override the default.

#### Which fields work best for AI training data and RAG indexing?

For RAG, index `title`, `description`, and `url` as the retrievable text context, keyed by `email`. For structured training/feature data, `emailDomain`, `hasBusinessEmail`, and `emailPattern` are the most consistently typed fields across every row.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| [LinkedIn B2B Emails Scraper: Verified Email Finder](../linkedin-b2b-emails-scraper-verified-email-finder) | Company-domain-grouped business emails from LinkedIn. |
| [Instagram B2B Email Scraper](../Instagram-B-Two-B-Email-Scraper) | Business emails and phone numbers from Instagram posts, reels, and profiles. |
| [Extract Emails, Contacts & Socials from Any Website](../extract-emails-contacts-socials-from-any-website) | Emails from Google-indexed pages across Alibaba plus 70+ other platforms. |
| [Instagram Comments Scraper With Lead Enrichment](../instagram-comments-scraper-with-lead-enrichment) | Warm-prospect leads mined from Instagram comment sections, with buying-intent flags. |

### Your feedback

Found a bug or a field that doesn't match what's documented here? Let us know via the Actor's issue tracker on its Apify Store listing so it can get fixed — active maintenance keeps this Actor's output reliable for everyone using it.

# Actor input Schema

## `businessKeywords` (type: `array`):

Product, industry, or company keywords to harvest supplier emails for (e.g. \['led lighting', 'stainless steel', 'packaging']). Each keyword is expanded into ~29 business-email search patterns in Bulk mode. Accepts the base `keywords` key as a fallback.

## `mode` (type: `string`):

Standard = a curated set of ~6 high-yield business-email dork patterns per keyword (fast, finishes inside the sync window). Bulk = fire ~29 engineered patterns per keyword for maximum corporate-email yield (longer runs). Default is Standard.

## `selectedPatterns` (type: `array`):

Run just a subset of the patterns by name (e.g. \['contact\_at\_domain', 'careers\_hiring', 'customer\_service']). Leave empty to use the mode default (Standard = ~6 curated, Bulk = all 29). Unknown names fail fast. See the README for the full pattern list.

## `maxEmailsPerPattern` (type: `integer`):

Cap on emails collected from each pattern, so yield spreads across patterns instead of exhausting on the first. Example: 10 → up to 10 emails per pattern. Default is 10.

## `maxRunSeconds` (type: `integer`):

Overall wall-clock budget. The run stops cleanly (streaming whatever it has collected) once this is reached, so a run-sync call finishes before the 300s timeout instead of being killed. Default 235 (max 270).

## `excludeFreeMail` (type: `boolean`):

Keep only corporate/business emails and drop free-mail addresses (gmail, yahoo, outlook, qq, 163, …). Default is true.

## `maxBusinessEmails` (type: `integer`):

Total unique business emails to harvest across every keyword and pattern before the run stops cleanly. Example: 100. Accepts the base `maxEmails` key as a fallback. Default is 20.

## `region` (type: `string`):

Optional country/city term added to every search (e.g. 'India', 'Shenzhen'). Leave empty to search globally. Accepts the base `location` key as a fallback.

## `businessDomains` (type: `array`):

Optional: keep only emails ending in these domains (e.g. \['.com.cn', '@company.com']). Leave empty to keep all business domains. Accepts the base `emailDomains` key as a fallback.

## `supplierMarketplace` (type: `string`):

B2B marketplace that drives the `site:` search restriction and the network label on every row. Accepts the base `platform` key as a fallback.

## `engine` (type: `string`):

Fetch engine — selects which Apify proxy group Google requests run through. Legacy: GOOGLE\_SERP proxy group (Google's SERP-optimized IPs). Residential: RESIDENTIAL proxy group (async requests over residential IPs). Accepts the base `engine` key.

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

Proxy settings. Google requests run through the Apify proxy group selected by the Engine input (GOOGLE\_SERP for Legacy, RESIDENTIAL for Residential) with automatic fresh-IP retries on block.

## Actor input object example

```json
{
  "businessKeywords": [
    "led lighting"
  ],
  "mode": "standard",
  "selectedPatterns": [],
  "maxEmailsPerPattern": 10,
  "maxRunSeconds": 235,
  "excludeFreeMail": true,
  "maxBusinessEmails": 20,
  "region": "",
  "businessDomains": [],
  "supplierMarketplace": "Alibaba",
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every harvested supplier lead in the default dataset: network, keyword, harvest mode, pattern name, matched query, email, email domain, business-email flag, result title, description, URL, and scrape timestamp.

# 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 = {
    "businessKeywords": [
        "led lighting"
    ],
    "selectedPatterns": [],
    "maxBusinessEmails": 20,
    "businessDomains": [],
    "supplierMarketplace": "Alibaba",
    "engine": "legacy",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = {
    "businessKeywords": ["led lighting"],
    "selectedPatterns": [],
    "maxBusinessEmails": 20,
    "businessDomains": [],
    "supplierMarketplace": "Alibaba",
    "engine": "legacy",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/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 '{
  "businessKeywords": [
    "led lighting"
  ],
  "selectedPatterns": [],
  "maxBusinessEmails": 20,
  "businessDomains": [],
  "supplierMarketplace": "Alibaba",
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/alibaba-email-scraper --silent --output-dataset

```

## MCP server setup

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