# Amazon B2b Lead Generator Email Scraper (`scrapers-hub/amazon-b2b-lead-generator-email-scraper`) Actor

Amazon B2B Lead Generator Email Scraper pulls seller and brand emails from Amazon search results - keyword, listing title, URL, description, email, email domain and country. 📧 Built for B2B prospecting, cold outreach and CRM enrichment at scale.

- **URL**: https://apify.com/scrapers-hub/amazon-b2b-lead-generator-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Amazon B2B Lead Generator Email Scraper

### 📧 Amazon B2B Lead Generator Email Scraper – Seller Emails, Brand Contacts & Business Leads

The **Amazon B2B lead generator email scraper** finds publicly listed business email addresses connected to Amazon marketplace pages, turning product keywords into a ready-to-use B2B prospect list. Instead of hitting Amazon's own anti-bot layer, this Amazon B2B lead generator email scraper runs a structured set of Google search queries scoped to a specific regional Amazon domain (`site:amazon.com`, `site:amazon.in`, `site:amazon.de`, and so on), then parses the result pages for contact details that sellers and brands have chosen to publish.

The output is a flat dataset of leads: the keyword that produced the lead, the page title, the source URL, the surrounding description text, the discovered email address and its domain. That structure makes it straightforward to push results into a CRM, a cold-outreach sequencer, or a spreadsheet for manual qualification. Consumer mailbox providers such as Gmail, Yahoo and Outlook are deliberately excluded from the query patterns so the harvest skews towards company-owned domains rather than personal inboxes.

***

### 📊 What Data Can You Extract with This Amazon B2B Lead Scraper?

Every dataset item is a single lead record. The fields fall into five natural groups:

| Category | Fields | What you get |
|---|---|---|
| 🔍 Search context | `keyword` | The exact search term from your input that surfaced this lead, so you can attribute every contact to a product niche |
| 🧾 Page identity | `title`, `url` | The title of the page the lead was found on and its canonical URL for manual verification |
| 📝 Context text | `description` | The long-form snippet or description text surrounding the contact, useful for qualifying relevance before outreach |
| 📧 Contact data | `email`, `email_domain` | The discovered business email address and the domain part, which is the single most useful qualification signal |
| 🌍 Provenance | `country`, `scrape_from` | The country targeting applied to the search and the Amazon regional source the lead was pulled from |

The field most teams underuse is `email_domain`. Because the query patterns strip out free consumer providers, the domain that remains is almost always a company's own domain — which means you can group leads by domain to deduplicate multi-contact companies, enrich against a firmographics provider, or filter out marketplaces and aggregators in a single pass before anyone spends time on outreach.

***

### 🌟 Key Features of the Amazon B2B Lead Scraper

| Feature | Description |
|---|---|
| 🎯 Keyword-driven prospecting | Supply a list of product niches or categories in `searchTerms` and the actor expands each one across dozens of contact-intent query patterns |
| 🛒 15 Amazon regional sites | `sourceRegion` targets a specific marketplace domain — US, India, Germany, UK, Japan, Canada, France, Italy, Spain, Brazil, Australia, Mexico, UAE, Saudi Arabia or Netherlands |
| 🌍 Country-level SERP targeting | `country` sets the geographic bias of the search, so results reflect what a buyer in that market would actually see |
| 🚫 Consumer-domain filtering | Query patterns explicitly exclude Gmail, Yahoo, Outlook and Hotmail addresses, biasing the harvest towards business domains |
| ⚡ Two scraping engines | `engine` switches between a residential-proxy performance mode and the standard GOOGLE\_SERP proxy mode |
| 🔁 Automatic deduplication | Emails are tracked globally across the whole run, so the same address is never written to the dataset twice |
| 📥 Hard result cap | `maxEmails` stops the run once your quota of leads is reached, keeping runs predictable |
| 🛡️ Managed proxy rotation | Proxy rotation is handled automatically by the actor; no proxy setup is required from you |
| 📤 Clean flat schema | Eight top-level fields with no nesting, so exports to CSV, Excel or Google Sheets stay readable |

***

### 🚀 Why Choose This Amazon B2B Lead Scraper?

**Contact-intent query patterns, not blind crawling.** The actor does not simply fetch pages and regex for `@`. It runs a curated library of search patterns built around phrases that reliably co-occur with published business contact details — "email us at", "get in touch", "for inquiries", "careers", "customer service", "for collaborations". Each pattern is combined with your keyword and the Amazon regional domain filter, which raises the ratio of usable leads per request.

**Marketplace-scoped, not the open web.** Every query is anchored to a specific Amazon domain. That constraint matters: it means the businesses you surface are demonstrably active on the marketplace you care about, rather than being any company that happens to mention a product category somewhere online.

**Regional precision for international outreach.** Selling into India is not the same motion as selling into Germany. Because `sourceRegion` and `country` are independent inputs, you can scope leads to `amazon.in` while running the search with Indian geographic targeting — or deliberately mix them when you want to see how a market looks from outside.

**Public data only, with a predictable budget.** The scraper reads what is already indexed and publicly visible. Combined with the `maxEmails` ceiling, that gives you a lead pipeline whose scope you control up front rather than an open-ended crawl.

***

### 📥 Input

```json
{
  "searchTerms": ["fitness equipment", "home decor", "electronics"],
  "country": "United States",
  "sourceRegion": "Amazon US",
  "engine": "legacy",
  "maxEmails": 20
}
```

#### 🔧 Amazon B2B Lead Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | array | Yes | — | List of keywords or product topics to search for on Amazon. Prefilled with `fitness equipment`, `home decor`, `electronics` |
| `country` | string | Yes | `United States` | Country used for Google SERP geographic targeting. Chosen from a long enum of country names |
| `sourceRegion` | string | Yes | `Amazon US` | The Amazon regional site to scrape from. One of: Amazon US, Amazon India, Amazon Germany, Amazon UK, Amazon Japan, Amazon Canada, Amazon France, Amazon Italy, Amazon Spain, Amazon Brazil, Amazon Australia, Amazon Mexico, Amazon UAE, Amazon Saudi Arabia, Amazon Netherlands |
| `engine` | string | No | `legacy` | Scraping method. `cost-effective` (Performance) uses residential proxies; `legacy` (Standard) uses the GOOGLE\_SERP proxy group |
| `maxEmails` | integer | Yes | `20` | Maximum number of email leads to collect. Minimum 1, maximum 10000 |

#### 💡 Input Examples

Single-niche prospecting on Amazon UK:

```json
{
  "searchTerms": ["pet supplies"],
  "country": "United Kingdom",
  "sourceRegion": "Amazon UK",
  "maxEmails": 100
}
```

Multi-keyword run on the Indian marketplace using the performance engine:

```json
{
  "searchTerms": ["ayurvedic skincare", "yoga mats", "organic tea"],
  "country": "India",
  "sourceRegion": "Amazon India",
  "engine": "cost-effective",
  "maxEmails": 500
}
```

Broad European sweep:

```json
{
  "searchTerms": ["kitchen appliances"],
  "country": "Germany",
  "sourceRegion": "Amazon Germany",
  "engine": "legacy",
  "maxEmails": 250
}
```

***

### 📤 Output

```json
{
  "keyword": "fitness equipment",
  "title": "Home Gym Equipment Supplier – Wholesale Enquiries",
  "url": "https://www.amazon.com/stores/page/EXAMPLE-STORE-ID",
  "description": "For wholesale and distribution enquiries email us at sales@examplefitness.com during business hours.",
  "email": "sales@examplefitness.com",
  "email_domain": "examplefitness.com",
  "country": "us",
  "scrape_from": "AMAZON US"
}
```

#### 🧾 Amazon B2B Lead Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword from `searchTerms` that produced this item |
| `title` | string | null | Title of the page the lead was extracted from |
| `url` | string | null | Canonical URL of the scraped item |
| `description` | string | null | Long-form description or snippet text surrounding the contact |
| `email` | string | null | Email address found for the item |
| `email_domain` | string | null | Email domain of the item |
| `country` | string | null | Country code applied to the search targeting |
| `scrape_from` | string | null | Label for the Amazon regional source the lead came from |

***

### 💻 How to Use the Amazon B2B Lead Scraper (Step by Step)

#### Step 1: Define your product niches

Start with `searchTerms`. This is the most consequential input in the whole configuration, because every downstream query is built by combining your keyword with a contact-intent pattern and a domain filter. Specific beats broad: "resistance bands" and "adjustable dumbbells" will each return a different set of sellers, whereas a single term like "sports" tends to produce generic pages. Three to eight well-chosen niche terms usually give better coverage than one vague one.

#### Step 2: Choose the Amazon regional site

Set `sourceRegion` to the marketplace where your prospects actually trade. A brand selling on `amazon.co.uk` is a different commercial entity, with different contacts, from the same brand's US operation. If you are unsure which region matters, run separate jobs per region rather than assuming overlap — the domain filter is exclusive, so one run only ever covers one marketplace.

#### Step 3: Set country targeting for the search

`country` biases the search results geographically and is converted internally to a two-letter code. It is independent of `sourceRegion` on purpose. Matching them (United States + Amazon US) gives the most natural results. Deliberately mismatching them — say, United Kingdom + Amazon US — can surface sellers who market internationally, which is occasionally exactly what an export-focused team wants.

#### Step 4: Pick a scraping engine

`engine` accepts `cost-effective` or `legacy`. The Performance option routes through residential proxies and is the faster, cheaper path. The Standard option uses Apify's GOOGLE\_SERP proxy group, which is purpose-built for search result pages and tends to be the more reliable choice when a run is returning fewer results than expected. If a job comes back thin, switching engines is the first thing to try.

#### Step 5: Cap the harvest with maxEmails

`maxEmails` is a hard ceiling on how many unique addresses the run will write. Because the actor deduplicates globally, the count reflects distinct addresses rather than raw matches. Start small — 20 to 50 — to sanity-check that the niche produces relevant contacts, then scale to hundreds or thousands once you have confirmed the keyword quality.

#### Step 6: Run the actor and watch the log

Start the run from the Apify Console, the API, or a schedule. The log prints the resolved configuration at startup — search terms, country code, source region, engine mode, proxy type and lead limit — followed by progress as each keyword and pattern combination is processed. Checking that the resolved configuration matches your intent takes five seconds and prevents wasted runs.

#### Step 7: Export, deduplicate by domain, and qualify

When the run finishes, export the dataset as JSON, CSV or Excel, or pull it through the API. The first cleanup pass should always be grouping by `email_domain`: it collapses multiple contacts at one company, exposes any aggregator domains that slipped through, and gives you a company-level view. Then use `description` and `title` to qualify relevance before anything is sent.

***

### 🔌 API Access & Integrations

Run the Amazon B2B lead generator email scraper synchronously and get the dataset back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~amazon-b2b-lead-generator-email-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["fitness equipment"],
    "country": "United States",
    "sourceRegion": "Amazon US",
    "engine": "legacy",
    "maxEmails": 50
  }'
```

Python, using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/amazon-b2b-lead-generator-email-scraper").call(
    run_input={
        "searchTerms": ["home decor", "kitchen appliances"],
        "country": "United Kingdom",
        "sourceRegion": "Amazon UK",
        "engine": "cost-effective",
        "maxEmails": 200,
    }
)

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

The dataset can also be pushed into Zapier, Make, Google Sheets or Slack, or delivered to your own endpoint with an Apify webhook that fires when a run succeeds.

***

### 💡 Best Use Cases for Amazon B2B Lead Data

#### 🤝 Wholesale and distribution outreach

Brands selling on Amazon frequently want additional distribution channels but rarely advertise it prominently. Filter leads whose `description` mentions wholesale, distribution or bulk terms, then use `email_domain` to confirm you are contacting the brand directly rather than a reseller. The `keyword` field tells you which product line to lead with in the first message.

#### 🏷️ Private-label supplier discovery

If you are building a private-label catalogue, the sellers already ranking in your target niche are a shortlist of people who understand that category's supply chain. Use `sourceRegion` to focus on the marketplace you intend to launch in, then work through leads grouped by `email_domain` to find manufacturers and white-label partners.

#### 📣 Influencer and affiliate partnerships

Many of the contact-intent patterns target phrases like "for collaborations" and "for business inquiries", which are the exact words used on partnership-focused pages. Records where `description` contains collaboration language are worth separating into their own list for affiliate or co-marketing outreach rather than cold sales.

#### 🌐 International market entry research

Running the same `searchTerms` across several values of `sourceRegion` produces comparable lead sets per marketplace. Counting distinct `email_domain` values per region gives a crude but genuinely informative read on how crowded each market is for that niche before you commit budget to a launch.

#### 🧰 SaaS and services prospecting

Vendors selling logistics, photography, PPC management, repricing tools or accounting services to marketplace sellers need a list of active sellers with reachable contacts. That is precisely this dataset: `email` for the contact, `url` for proof they are trading, and `title` for a personalised opening line.

#### 📊 CRM enrichment and list building

Existing CRM records often carry a company name but no working contact address. Run the scraper against your target categories, then join on `email_domain` to fill gaps in accounts you already track. Records that do not match anything existing become net-new pipeline.

#### 🧑‍💼 Recruitment and talent sourcing

Several query patterns specifically target careers, hiring and HR language. Leads whose `description` includes hiring intent identify companies that are actively expanding, which is useful both for recruiters and for anyone selling into growing teams.

***

### ⚙️ Tips for Better Amazon B2B Lead Scraping Results

- **Use narrow, commercial keywords.** "Adjustable kettlebells" outperforms "fitness". Narrow terms match the language on seller pages and produce fewer irrelevant hits.
- **Run one region per job.** Because `sourceRegion` resolves to a single domain filter, splitting regions across separate runs keeps attribution clean and makes the `scrape_from` field genuinely useful.
- **Switch `engine` when results are thin.** If a run returns far fewer leads than `maxEmails`, try the other engine before changing keywords — the two proxy paths behave differently against search result pages.
- **Start with a small `maxEmails` for validation.** A 20-lead test run costs little and tells you immediately whether the keyword is producing relevant businesses.
- **Deduplicate by `email_domain` before outreach.** Multiple addresses at one company should be one prospect, not several. This single step usually shrinks a raw list by a meaningful percentage.
- **Discard obvious platform addresses.** Any address on a marketplace, hosting or CDN domain is noise. Filtering on `email_domain` catches these in one rule.

***

### 🛠️ Troubleshooting

**Why did my run return zero or very few leads?**
The most common cause is an over-broad keyword that does not match the contact-intent phrasing the patterns look for. Try a more specific product term. The second most common cause is engine choice — switch `engine` between `cost-effective` and `legacy` and re-run before concluding the niche is empty.

**Why do some emails look unrelated to the seller?**
The scraper extracts addresses that appear in the indexed page content around a match. Occasionally that includes an agency, a support desk or a third-party service mentioned on the same page. Use `url` and `description` to verify the association before contacting anyone.

**Can I get more leads than `maxEmails`?**
No — the limit is enforced globally across the run and the actor stops writing once it is hit. If you need more, raise `maxEmails` (up to 10000) or split the work across multiple runs with different `searchTerms`.

**The run stopped early with a proxy error.**
The actor requires a working proxy configuration and will exit if it cannot obtain one. Confirm your Apify account has proxy access enabled for the group the selected engine uses, then re-run. Proxy rotation itself is handled automatically and needs no configuration from you.

**Why is `scrape_from` different from the region name I selected?**
`scrape_from` is a display label derived from the resolved Amazon domain rather than a verbatim copy of your input. It identifies the same marketplace, just formatted differently.

***

### ❓ Frequently Asked Questions About Amazon B2B Lead Scraping

**What does the Amazon B2B lead generator email scraper actually do?**
It searches for publicly published business email addresses associated with pages on a chosen Amazon regional domain, using keyword-driven, contact-intent search patterns, and writes each discovered lead as a flat dataset record.

**Does it scrape Amazon.com directly?**
No. It queries Google with a `site:` filter scoped to the selected Amazon domain and parses the search result pages. This is why the output includes a `snippet`-style `description` rather than structured product data.

**Which Amazon marketplaces are supported?**
Fifteen: US, India, Germany, UK, Japan, Canada, France, Italy, Spain, Brazil, Australia, Mexico, UAE, Saudi Arabia and Netherlands, selected via `sourceRegion`.

**How many emails can I collect in one run?**
Between 1 and 10000, set by `maxEmails`. The default is 20, which is deliberately small so a first run is quick to evaluate.

**Are Gmail and Yahoo addresses included?**
The query patterns explicitly exclude the major free consumer providers, so the harvest skews strongly towards company-owned domains. A small number of consumer addresses may still appear where a business publishes one as its official contact.

**What is the difference between `country` and `sourceRegion`?**
`country` controls the geographic targeting of the search itself. `sourceRegion` controls which Amazon domain the results are restricted to. They are independent and can be set to different markets on purpose.

**Which engine should I choose?**
Start with the default. `legacy` (Standard) uses the GOOGLE\_SERP proxy group; `cost-effective` (Performance) uses residential proxies and is faster and cheaper. If one is returning thin results, switch to the other.

**Do I need to configure proxies?**
No. Proxy rotation is handled automatically based on the engine you select. There is no proxy input to fill in.

**Are duplicate emails removed?**
Yes. Addresses are tracked in a global set across the entire run, so each unique address is written at most once.

**Can I export the leads to CSV or Google Sheets?**
Yes. Apify datasets export to JSON, CSV, Excel, XML and HTML, and can be pushed to Google Sheets through the API, Zapier or Make.

**Can I schedule recurring lead generation runs?**
Yes. Use Apify Schedules to run the actor daily, weekly or on any cron expression, and attach a webhook so new leads flow into your CRM automatically.

**Why is the `description` field sometimes empty?**
The description is taken from the text surrounding the match on the result page. Some pages provide no usable snippet, in which case the field is null while the email and URL remain valid.

**Is the collected data legal to use for outreach?**
The scraper only collects information that is already published and publicly accessible. How you use it is governed by the marketing and privacy laws of your jurisdiction and your recipients' — GDPR, CAN-SPAM, PECR and equivalents. Confirm your legal basis before sending.

**How do I attribute a lead back to a product niche?**
The `keyword` field on every record contains the exact search term that produced it, so segmentation by niche needs no extra work.

**Can I run this Amazon B2B lead scraper from my own application?**
Yes. Use the Apify API, the `apify_client` Python or JavaScript SDK, or a plain cURL call to the `run-sync-get-dataset-items` endpoint shown above.

***

### 🆘 Support & Feedback

Found a bug, or seeing results that do not look right? Open a report on the **Issues** tab of this actor with your input configuration and, where possible, a run ID — that combination makes problems far faster to reproduce.

Need a custom version — a different marketplace, extra enrichment fields, a tailored export format, or a private build for your team? Email **scraperhubapi@gmail.com** and describe what you need.

If this Amazon B2B lead generator email scraper saves you time, please leave a review on the actor page. Ratings and written feedback directly shape which improvements get built next.

***

### ⚖️ Disclaimer

This Amazon B2B lead generator email scraper collects only publicly available information that is already indexed and accessible without authentication. It does not bypass logins, access private seller dashboards, or retrieve any data hidden behind an account.

Email addresses are personal data under GDPR, UK GDPR, CCPA and comparable regimes, even when they belong to a business. You are responsible for establishing a lawful basis for processing, honouring opt-out and erasure requests, and complying with anti-spam legislation such as CAN-SPAM, CASL and PECR before using any collected address for outreach. You are also responsible for respecting the terms of service of Amazon and of any search engine involved in producing these results.

To request removal of specific data collected by this actor, email **scraperhubapi@gmail.com** with the relevant details and it will be actioned.

# Actor input Schema

## `searchTerms` (type: `array`):

List of keywords or topics to search for on Amazon.

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

Select the country for Google SERP targeting.

## `sourceRegion` (type: `string`):

Select the specific Amazon regional site to scrape data from.

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

Select your preferred scraping method. ⚡ Performance (New): Faster, cheaper, uses residential proxies. 🛡️ Standard: Reliable, uses GOOGLE\_SERP proxy, but slower.

## `maxEmails` (type: `integer`):

Limit the number of emails to collect.

## Actor input object example

```json
{
  "searchTerms": [
    "fitness equipment",
    "home decor",
    "electronics"
  ],
  "country": "United States",
  "sourceRegion": "Amazon US",
  "engine": "legacy",
  "maxEmails": 20
}
```

# Actor output Schema

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

Records scraped by Amazon B2b Lead Generator Email Scraper, stored in the run's default dataset.

# 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 = {
    "searchTerms": [
        "fitness equipment",
        "home decor",
        "electronics"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/amazon-b2b-lead-generator-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 = { "searchTerms": [
        "fitness equipment",
        "home decor",
        "electronics",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/amazon-b2b-lead-generator-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 '{
  "searchTerms": [
    "fitness equipment",
    "home decor",
    "electronics"
  ]
}' |
apify call scrapers-hub/amazon-b2b-lead-generator-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/amazon-b2b-lead-generator-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/gf52qSbgaxNhBzVOK/builds/ctSxyhz1kuLZOfmpg/openapi.json