# Amazon Contact Extractor (`scrapers-hub/amazon-contact-extractor`) Actor

Amazon Contact Extractor finds seller contact emails by keyword and country, returning email, email type, email domain, listing title, URL and source region. 📇 Ideal for B2B lead generation, supplier outreach and marketplace research.

- **URL**: https://apify.com/scrapers-hub/amazon-contact-extractor.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 $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Contact Extractor

### 📧 Amazon Contact Extractor – Amazon Seller Email & Lead Data Extraction

The **Amazon Contact Extractor** finds publicly indexed email addresses associated with Amazon listings and storefronts, returning each discovery as a structured lead record containing the email address, its domain, the B2B/B2C classification, the page title and description it was found on, the source URL, the keyword that produced it, and the Amazon regional index it came from.

Rather than crawling Amazon directly, the Actor works from publicly indexed search results scoped to Amazon domains. You supply a list of search terms, choose which of fifteen Amazon regional marketplaces to target, pick a country context for the search, decide whether you want business or consumer email addresses, and set a cap on how many results to collect. The Actor then works through those combinations and writes one dataset row per unique email address found.

This makes the Amazon Contact Extractor a practical lead generation tool for agencies selling services to Amazon sellers, brands looking for distribution partners, market researchers mapping a category, and sales teams building prospect lists in a specific product niche.

***

### 📊 What Data Can You Extract with This Amazon Contact Extractor?

Each dataset item is one email address together with the context in which it was discovered. The nine output fields group into five categories:

| Category | Fields | What you get |
|---|---|---|
| 📧 Contact data | `email`, `email_domain` | The extracted email address and the domain portion after the `@`, ready for domain-level grouping |
| 🏷️ Lead classification | `email_type` | Whether the address was classified as `B2B` or `B2C`, matching the `emailType` you selected |
| 📄 Page context | `title`, `description` | The title and descriptive snippet of the page where the address was found |
| 🔗 Provenance | `url`, `scrape_from` | The canonical URL of the source page and the Amazon domain the result came from, such as `amazon.com` or `amazon.co.uk` |
| 🌍 Search context | `keyword`, `country` | The specific search term that produced this record and the country context the search ran under |

The field pairing that makes this dataset immediately actionable is `email_domain` with `email_type`. Together they let you sort a raw extraction into two very different pipelines in one step: corporate domains that warrant a business outreach sequence, and consumer mailbox providers that belong in an entirely different bucket — or in no bucket at all, depending on your compliance posture.

***

### 🌟 Key Features of the Amazon Contact Extractor

| Feature | Description |
|---|---|
| 🌐 15 Amazon regional marketplaces | Target Amazon US, India, Germany, UK, Japan, Canada, France, Italy, Spain, Brazil, Australia, Mexico, UAE, Saudi Arabia or Netherlands through the `sourceRegion` field |
| 🏷️ B2B / B2C filtering | The `emailType` setting keeps only business domains or only consumer mailbox providers, so your export is already segmented |
| 🔎 Multi-keyword search | `searchTerms` accepts a list of queries, and each result records the exact `keyword` that produced it for attribution |
| ⚙️ Two scraping engines | Choose `cost-effective`, which uses residential proxies with async requests for faster and cheaper collection, or `legacy`, which uses a dedicated SERP proxy with traditional selectors |
| 🌍 Country-scoped search results | The `country` field sets the geographic context of the underlying search, drawn from a list of well over a hundred territories |
| 🎯 Hard result cap | `maxEmails` stops collection at your chosen limit, anywhere from 1 to 10,000, giving you direct control over run cost |
| 🔁 Automatic proxy rotation | Proxy handling is managed internally with retry logic and rotating sessions — no proxy configuration required from you |
| 🧹 Built-in deduplication | Addresses already seen within a run are not written again, so the dataset contains unique contacts rather than repeated hits |
| 💾 Resumable progress tracking | Run state is persisted to a key-value store, so a long extraction can pick up its cursor rather than restarting from the beginning |

***

### 🚀 Why Choose This Amazon Contact Extractor?

**Segmentation happens during extraction, not after it.** The `emailType` setting filters at collection time: choosing `B2C` keeps only consumer mailbox domains, while `B2B` excludes them and keeps corporate addresses. That means the dataset you export is already the list you intended to build, rather than a mixed pile requiring a manual sorting pass.

**Genuine multi-marketplace reach.** Fifteen `sourceRegion` options map to the actual Amazon country domains — `amazon.co.uk`, `amazon.de`, `amazon.co.jp` and so on. Each result records its origin in `scrape_from`, so a run covering several marketplaces stays fully attributable and you can compare lead density between regions.

**Cost is under your control.** `maxEmails` is a hard stop, and the `engine` choice gives you an explicit speed-versus-reliability trade-off. The cost-effective engine uses residential proxies with concurrent requests; the legacy engine is slower and more expensive but uses a dedicated SERP proxy. You decide which matters more for a given job.

**Every lead carries its own provenance.** `keyword`, `url`, `title`, `description` and `scrape_from` travel with each email address. When a sales rep asks where a contact came from, the answer is in the row — which is also what makes the dataset defensible from a compliance standpoint.

***

### 📥 Input

The Amazon Contact Extractor requires five fields: your search terms, a country context, an Amazon regional index, an email type and a result cap.

```json
{
  "searchTerms": ["fitness", "gym", "workout"],
  "country": "United States",
  "sourceRegion": "Amazon US",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20
}
```

#### 🔧 Amazon Contact Extractor Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | array | ✅ Yes | prefill `["fitness", "gym", "workout"]` | List of queries to find Amazon profiles |
| `country` | string (enum) | ✅ Yes | `United States` | Specify the country to target for search results. Over a hundred territories are available, including United Kingdom, Canada, Australia, Germany, France, India, Japan, Brazil, Italy, Spain, Netherlands, Singapore, UAE and Saudi Arabia |
| `sourceRegion` | string (enum) | ✅ Yes | `Amazon US` | Select the regional index to target. 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 |
| `emailType` | string (enum) | ✅ Yes | `B2C` | Choose one — `B2C` keeps consumer mailbox domains only, `B2B` excludes them |
| `maxEmails` | integer | ✅ Yes | `20` | Maximum number of emails to collect. Minimum 1, maximum 10,000 |
| `engine` | string (enum) | No | `legacy` | Scraping engine. `cost-effective` uses residential proxies with async requests for faster, cheaper scraping. `legacy` uses a SERP proxy with traditional selectors — more reliable but slower and more expensive |

#### 💡 Input Examples

**B2B leads in the UK fitness category:**

```json
{
  "searchTerms": ["supplements", "protein powder"],
  "country": "United Kingdom",
  "sourceRegion": "Amazon UK",
  "emailType": "B2B",
  "engine": "cost-effective",
  "maxEmails": 200
}
```

**German marketplace, larger batch:**

```json
{
  "searchTerms": ["haushaltsgeräte", "küche"],
  "country": "Germany",
  "sourceRegion": "Amazon Germany",
  "emailType": "B2B",
  "maxEmails": 500
}
```

**Quick consumer-side test run:**

```json
{
  "searchTerms": ["yoga mat"],
  "country": "India",
  "sourceRegion": "Amazon India",
  "emailType": "B2C",
  "maxEmails": 20
}
```

***

### 📤 Output

Each unique email address becomes one dataset item. A representative record looks like this:

```json
{
  "keyword": "fitness",
  "title": "Home Gym Equipment Store – Fitness Essentials",
  "url": "https://www.amazon.com/stores/example-fitness-brand",
  "description": "Shop resistance bands, dumbbells and workout accessories. Contact our support team for wholesale enquiries.",
  "email": "wholesale@examplefitnessbrand.com",
  "email_domain": "examplefitnessbrand.com",
  "email_type": "B2B",
  "country": "United States",
  "scrape_from": "amazon.com"
}
```

#### 🧾 Amazon Contact Extractor Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword that produced this item |
| `title` | string | null | Title of the item |
| `url` | string | null | Canonical URL of the scraped item |
| `description` | string | null | Long-form description text |
| `email` | string | null | Email address found for the item |
| `email_domain` | string | null | Email domain of the item |
| `email_type` | string | null | Email type of the item |
| `country` | string | null | Country |
| `scrape_from` | string | null | Scrape from of the item |

The `scrape_from` field records the Amazon domain the result originated from — `amazon.com`, `amazon.co.uk`, `amazon.de` and so on — which is what allows a multi-region campaign to be split back out cleanly after export. All fields are nullable.

***

### 💻 How to Use the Amazon Contact Extractor (Step by Step)

#### Step 1: Open the Amazon Contact Extractor on Apify

Sign in to your Apify account and open the Actor page, then press **Start** to reveal the input form. A free account is enough to begin, and it gives you a console where every run, log and dataset is preserved. That history matters for lead generation work, because being able to point at the exact run that produced a contact is part of keeping the process auditable.

#### Step 2: Write effective search terms

`searchTerms` is the input that most determines your yield. Generic single words like `fitness` cast a wide net but produce diffuse results. Specific product categories, niche descriptors or brand-adjacent phrases return fewer but far more relevant contacts. Supply several related terms in the list rather than one broad one — each result records its originating `keyword`, so you can see afterwards which terms actually performed and refine the list for the next run.

#### Step 3: Select the Amazon regional index

`sourceRegion` decides which Amazon country domain is searched. Setting it to `Amazon UK` scopes results to `amazon.co.uk`, `Amazon Japan` to `amazon.co.jp`, and so on across the fifteen supported marketplaces. Match this to the market you actually sell into. Pairing it sensibly with `country` — which sets the geographic context of the underlying search — gives noticeably more relevant results than mixing, say, a Japanese marketplace with a Brazilian search context.

#### Step 4: Choose B2B or B2C

`emailType` is a filter applied during extraction, not a label added afterwards. `B2B` excludes consumer mailbox providers and keeps corporate domains, which is what most agency and wholesale outreach requires. `B2C` does the reverse, keeping only consumer domains. Pick deliberately: running the wrong one means the addresses you wanted were discarded rather than merely mislabelled, and you will need a fresh run to recover them.

#### Step 5: Pick an engine and set your cap

`engine` defaults to `legacy`, which uses a dedicated SERP proxy and traditional selectors — more reliable, but slower and more expensive to run. `cost-effective` uses residential proxies with asynchronous requests, which is faster and cheaper. For exploratory runs, cost-effective is usually the sensible starting point. Set `maxEmails` to a modest number such as 20 or 50 for your first run so you can assess result quality before committing to a large extraction.

#### Step 6: Run the Actor and read the log

Start the run and watch the live log. It reports each email as it is found and pushed to the dataset, along with the page it came from. This visibility is genuinely useful mid-run: if you are seeing addresses that do not fit your intended segment, you can stop early, adjust `searchTerms` or `emailType`, and restart rather than paying for a full run of unusable data.

#### Step 7: Review, verify and export

Open the **Output** tab and review the dataset before doing anything with it. Check that `email_type` matches what you requested, that `scrape_from` shows the expected marketplace, and that the `title` and `description` context makes the contacts look genuinely relevant. Export to CSV or JSON, then run the addresses through an email verification service before any outreach — extracted addresses are as current as the page that published them, which is not always very current.

***

### 🔌 API Access & Integrations

Trigger the Amazon Contact Extractor from the Apify API and receive the dataset in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~amazon-contact-extractor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["fitness", "gym", "workout"],
    "country": "United States",
    "sourceRegion": "Amazon US",
    "emailType": "B2C",
    "engine": "legacy",
    "maxEmails": 20
  }'
```

The equivalent with the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "searchTerms": ["supplements", "protein powder"],
    "country": "United Kingdom",
    "sourceRegion": "Amazon UK",
    "emailType": "B2B",
    "engine": "cost-effective",
    "maxEmails": 200,
}

run = client.actor("scrapers-hub/amazon-contact-extractor").call(run_input=run_input)

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

The Actor also connects to Zapier, Make, Google Sheets, Slack, Airtable and any custom endpoint through Apify webhooks, so new leads can flow directly into your CRM as each run completes.

***

### 💡 Best Use Cases for Amazon Contact Data

#### 🤝 Agency Prospecting for Amazon Sellers

Agencies offering PPC management, listing optimisation or brand registry services need a pipeline of sellers to approach. Setting `emailType` to `B2B` and running category-specific `searchTerms` produces a list of corporate domains active in that niche, with `title` and `description` giving each rep enough context to personalise the first message.

#### 🌍 Multi-Marketplace Expansion Research

Brands considering entry into a new Amazon marketplace can run the same `searchTerms` across several `sourceRegion` values. Comparing the volume and domain composition of results — visible through `scrape_from` and `email_domain` — gives a rough read on how crowded each market is with established sellers in that category.

#### 📦 Wholesale and Distribution Partner Discovery

Manufacturers looking for distributors can target product-category `searchTerms` with `emailType` set to `B2B`. The `email_domain` field is the useful one here: recurring corporate domains across multiple results usually indicate a substantial operation rather than a single-listing seller, which is exactly the profile a distribution conversation needs.

#### 📊 Category and Competitive Mapping

Market researchers can build a picture of who operates in a given Amazon category by running broad `searchTerms` and analysing the distribution of `email_domain` values. Aggregating by domain reveals concentration — whether a category is dominated by a handful of large operators or fragmented across many small sellers.

#### 📣 B2B Outreach Campaign Building

Sales teams running structured outreach need segmented lists, not raw dumps. Because `keyword`, `email_type` and `scrape_from` are recorded per row, a single export can be sliced into distinct campaign segments — by product interest, by marketplace, by lead type — without any enrichment step in between.

#### 🔍 Supplier and Sourcing Research

Procurement teams sourcing products can use `searchTerms` describing the item they need and `sourceRegion` set to the marketplace where those suppliers concentrate. The `url` and `description` fields provide enough context to assess each result before an approach is made.

#### 📈 Territory Planning for Sales Teams

Running the same category terms across several `country` and `sourceRegion` combinations produces comparable lead counts per territory. Sales leaders use that to weight headcount and quota against where addressable contacts actually exist, rather than assuming even distribution across markets.

***

### ⚙️ Tips for Better Amazon Contact Extraction Results

- **Use several specific search terms rather than one broad one.** Narrow, category-accurate phrases return more relevant contacts, and the per-row `keyword` field shows you afterwards which terms earned their place.
- **Align `country` with `sourceRegion`.** Pairing Amazon UK with a United Kingdom search context produces more coherent results than mixing a marketplace with an unrelated geography.
- **Start small, then scale.** Run with `maxEmails` at 20 first. Inspect the quality, adjust `searchTerms` and `emailType`, and only then increase the cap.
- **Try the cost-effective engine before the legacy one.** It uses residential proxies with async requests and is both faster and cheaper. Fall back to `legacy` only if result quality is not what you need.
- **Verify every address before outreach.** Extracted emails reflect what was published on the source page, which may be stale. A verification pass protects your sending reputation.
- **Allow generous run timeouts for large caps.** A `maxEmails` value in the thousands means many search pages. Extend the timeout in Run Options rather than letting a long job be cut short.

***

### 🛠️ Troubleshooting

**The run finished with fewer emails than `maxEmails`. Why?**
`maxEmails` is a ceiling, not a target. If the search terms and marketplace combination simply does not surface that many publicly indexed addresses, the run ends early. Broaden your `searchTerms`, try a different `sourceRegion`, or switch `emailType` — a B2B run on a consumer-heavy category will naturally yield less.

**I selected B2B but expected to see Gmail addresses too.**
That is the filter working as designed. `B2B` explicitly excludes consumer mailbox providers. To collect those addresses, run again with `emailType` set to `B2C`.

**The run is slow. Can I speed it up?**
Set `engine` to `cost-effective`. It uses residential proxies with asynchronous concurrent requests, which is substantially faster than the `legacy` engine's synchronous SERP-proxy approach.

**Can I configure my own proxy?**
No proxy setting is exposed in the input. Proxy rotation, session refresh and retry handling are all managed internally by the Actor.

**Why do some rows have an empty `description` or `title`?**
Every output field is nullable. Not every source page exposes a usable title or descriptive snippet, and the Actor records `null` rather than fabricating a value.

***

### ❓ Frequently Asked Questions About Amazon Contact Extraction

**What does the Amazon Contact Extractor do?**
It searches publicly indexed pages scoped to Amazon domains using the keywords you supply, extracts email addresses found in those results, filters them by B2B or B2C type, and outputs each as a lead record with its keyword, page title, description, source URL, email domain and originating Amazon marketplace.

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

**What is the difference between B2B and B2C mode?**
`B2C` keeps only addresses on consumer mailbox domains. `B2B` excludes those and keeps corporate domains. The filter is applied during collection, so choose before the run rather than planning to sort afterwards.

**What is the difference between the two engines?**
`cost-effective` uses residential proxies with asynchronous requests, making it faster and cheaper. `legacy` uses a dedicated SERP proxy with traditional selectors — more reliable, but slower and more expensive. `legacy` is the default.

**How many emails can one run collect?**
`maxEmails` accepts values from 1 to 10,000. Larger caps mean longer runs, so extend your run timeout accordingly.

**Do I need an Amazon account or API key?**
No. The Actor requires only your Apify token when running through the API, and nothing beyond a signed-in console session otherwise.

**Are duplicate emails removed?**
Yes. Addresses already seen during a run are tracked and not written to the dataset a second time.

**Can I search several keywords in one run?**
Yes. `searchTerms` is an array. Each output row records the specific `keyword` that produced it, so attribution survives into your export.

**What does the `scrape_from` field contain?**
The Amazon domain the result originated from, such as `amazon.com` or `amazon.co.uk`. It is what lets you split a multi-marketplace run back out by region.

**Are the extracted email addresses verified?**
No. The Actor extracts addresses as they appear on publicly indexed pages. Run them through a dedicated verification service before any outreach campaign.

**Can I configure proxies myself?**
No. Proxy rotation is handled automatically and is not exposed as an input field.

**Does the Amazon Contact Extractor scrape product prices or reviews?**
No. Its scope is contact extraction. The output covers email addresses and the page context they were found in — there are no pricing, inventory or review fields.

**What export formats are available?**
JSON, CSV, Excel, XML, HTML table and RSS, from the Apify dataset view or through the API.

**Can I schedule recurring extraction runs?**
Yes. Use the Schedules feature in the Apify console to rerun the same configuration periodically and build an expanding lead database over time.

**Is extracting Amazon seller contact data legal?**
The Actor collects only publicly indexed information. However, email addresses relating to identifiable individuals are personal data under GDPR, CCPA and similar regimes. You must establish a lawful basis for processing, honour opt-outs, and comply with anti-spam legislation such as GDPR, CAN-SPAM and PECR before sending any outreach.

***

### 🆘 Support & Feedback

If a run fails, results look wrong, or a field behaves differently from what is documented here, please open a report in the **Issues** tab on the Actor page so it can be investigated and fixed.

Need a custom build — additional data points, a different source, a tailored output shape, or contact extraction for another marketplace — email **scraperhubapi@gmail.com** with your requirements.

If the Amazon Contact Extractor is useful to your work, a review on the Apify Store genuinely helps other users find it and directly influences what gets improved next.

***

### ⚖️ Disclaimer

The Amazon Contact Extractor collects only publicly available information from publicly indexed web pages. It does not access private accounts, bypass authentication, or retrieve data hidden behind access controls.

Email addresses are personal data. If you use this Amazon contact extractor to collect addresses relating to identifiable individuals, you become a data controller under GDPR, the UK GDPR, CCPA and comparable frameworks. That carries concrete obligations: you need a lawful basis for processing — legitimate interest is the usual route for B2B prospecting, and it must be documented and balanced; you must inform data subjects of your processing; you must honour access, rectification and erasure requests; and you must retain data only for as long as it is genuinely needed.

Outreach using extracted addresses is separately regulated. GDPR, CAN-SPAM, CASL, PECR and equivalent anti-spam laws impose requirements around consent, sender identification, accurate subject lines and functioning opt-out mechanisms. Sending unsolicited commercial email in breach of these rules carries real penalties regardless of how the address was obtained.

You are also responsible for complying with the terms of service of Amazon and of any search platform whose results the extraction touches, and for using the data in a way that does not place an unreasonable burden on those services.

This Actor is not affiliated with, endorsed by, or sponsored by Amazon.com, Inc. or any of its subsidiaries. If you believe data collected by this Actor relates to you and you would like it removed, contact **scraperhubapi@gmail.com** and the request will be handled promptly.

# Actor input Schema

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

Specify the country to target for Google search results.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

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

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Enter the maximum number of emails to collect.

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

List of queries to find Amazon profiles.

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

Select the regional index to target.

## Actor input object example

```json
{
  "country": "United States",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20,
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ],
  "sourceRegion": "Amazon US"
}
```

# Actor output Schema

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

Records scraped by Amazon Contact Extractor, 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",
        "gym",
        "workout"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/amazon-contact-extractor").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",
        "gym",
        "workout",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/amazon-contact-extractor").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",
    "gym",
    "workout"
  ]
}' |
apify call scrapers-hub/amazon-contact-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/amazon-contact-extractor"
        }
    }
}

```

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/rt4hlGU5UUeHySBn7/builds/xp8BgUwm7zCSFnrtU/openapi.json