# Amazon Sellers Scraper - Seller Leads & Contacts (`b2b_leads/amazon-sellers-real-time-data-scraper`) Actor

Collect Amazon seller leads fast: business names, addresses, phones, emails, websites, feedback stats and catalog sizes. Enable keyword search, category rankings, listing URLs, seller lists or product links — cap each source separately across 24 marketplaces. Free plans export a small sample.

- **URL**: https://apify.com/b2b\_leads/amazon-sellers-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 results

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

Learn more: https://docs.apify.com/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

## Amazon Sellers Real-Time Data

Collect Amazon marketplace seller data at scale — seller names, business details, contact
emails, phone numbers, websites, feedback statistics, and catalog sizes — streamed to your
dataset in real time as each seller is processed.

> **Paid only / free tier:** free Apify accounts are limited to a small sample of results
> per run (2 sellers) and cannot use this actor for full exports. **Upgrade to a paid Apify
> plan for full, unlimited data.** The restriction is applied transparently: the run log
> states it, the run output includes a `paywall` object, and the run exits gracefully —
> never with an error.

***

### What it does

One run takes you from "I want sellers who sell X" to a clean lead list:

1. **Discovery** — sellers are found from any combination of sources you enable: keyword
   search (on by default), category best sellers, category new releases, trending (movers
   & shakers), a listing URL, a direct seller list, or product links.
2. **Enrichment** — every seller is enriched with business name, business address, phone,
   contact emails, website, positive-feedback percentage, feedback counts (30/90 days and
   12 months), ratings count, and total listings count.
3. **Email discovery (optional)** — when a seller profile has no email and the seller lists
   a website, the actor can check the seller's own website for contact emails.
4. **Streaming output** — each seller is pushed to the dataset the moment it is ready. RAM
   stays flat during long scrapes and you can watch results arrive live.

Every business goes to the dataset even if it has no lead details. Nothing is filtered out,
so runtime per 1,000 sellers is predictable. Enabling lead details adds a little extra time
per seller.

### Outcomes it delivers

- **Seller leads** — business name, address, phone, emails, website for outreach.
- **Market mapping** — who sells in a niche, how big their catalogs are, how customers
  rate them.
- **Competitor monitoring** — track sellers across keywords, categories, and marketplaces.
- **CRM-ready data** — flat JSON rows (one per seller) with stable field names; webhook
  push to Zapier/Make/Slack/your own service included.

### Who it is for

- **Lead generation agencies** selling Amazon-seller outreach campaigns.
- **B2B sales teams** targeting e-commerce companies (suppliers, SaaS, logistics, agencies).
- **Brand protection & MAP enforcement teams** finding who sells their products and in which
  marketplaces.
- **Market researchers and analysts** measuring seller density, catalogs, and reputation.
- **E-commerce consultants** building seller lists for clients by niche and country.
- **Recruiters and M\&A scouts** finding e-commerce businesses with contactable owners.
- **Investors and FBA aggregators** screening sellers by catalog size and feedback health.
- **SaaS growth teams** building enriched prospect databases.

### Use cases

- Build a prospect list of sellers in a niche ("wireless earbuds", "dog harness") with
  business address + email.
- Collect all best sellers in a category and enrich them into leads.
- Monitor who sells your brand's ASINs across the US, UK, DE, FR, IT, ES marketplaces.
- Map competitors per category: seller count, catalog size, feedback percent.
- Enrich a list of seller IDs you already have (from your own tooling) into full contacts.
- Track trending sellers via Movers & Shakers before they get big.
- Pipe every seller straight into your CRM via webhook while the run is still going.
- Schedule recurring runs on the same keywords to detect new entrants in a niche.
- Cross-marketplace research: run the same keyword across 24 marketplaces.
- Filter locally after the run: sellers with email, with phone, with 1,000+ listings, etc.

### Supported marketplaces

US, GB, DE, FR, IT, ES, CA, AU, IN, JP, MX, AE, NL, SE, PL, BE, SG, BR, TR, SA, EG, ZA,
IE, CN — set with the `country` input (US by default). The actor matches each marketplace's
language and currency automatically.

***

### Input schema (every field)

The input form is organized into collapsible sections. Each discovery source has its own
section with an **enable checkbox** and its own max-sellers number — **Keyword search is
on by default; every other source is off until you enable it.** You cap each source
separately: a source exports at most its own "Max sellers" number, and enabling several
sources simply adds those budgets together.

#### 🔤 Keyword search (enabled by default)

| Field | Type | Default | Description |
|---|---|---|---|
| `enableKeywordSearch` | boolean | `true` | Discover sellers from marketplace search results for your keywords. |
| `keywords` | string | `"wireless earbuds"` | One or more keywords, comma or newline separated. Example: `"wireless earbuds, yoga mat"`. |
| `maxSellersPerKeyword` | integer | `10` | Max unique sellers to export from keyword search in this run (all keywords combined). Free plans are capped to a small sample per run regardless of this setting. |

#### 🏆 Category rankings (off by default)

| Field | Type | Default | Description |
|---|---|---|---|
| `enableCategoryRankings` | boolean | `false` | Discover sellers from a category ranking list. |
| `rankListType` | select | `bestsellers` | `bestsellers`, `new-releases`, or `movers-shakers` (trending). |
| `category` | string | `""` | Category path (`"fashion"`, `"sports-and-outdoors"`) or numeric node id. |
| `maxSellersPerCategory` | integer | `10` | Max unique sellers to export from this ranking list. |

#### 🔗 Listing URLs (off by default)

| Field | Type | Default | Description |
|---|---|---|---|
| `enableListingUrls` | boolean | `false` | Collect sellers directly from a listing URL you paste. |
| `categoryUrls` | string\[] | `[]` | Full listing URLs (the first is used per run). |
| `maxSellersPerListing` | integer | `10` | Max unique sellers to export from the listing. |

#### 🏪 Seller list (off by default)

| Field | Type | Default | Description |
|---|---|---|---|
| `enableSellerList` | boolean | `false` | Enrich sellers you already know — no discovery, direct enrichment. |
| `sellerUrls` | string\[] | `[]` | Seller profile URLs to enrich (merged with the ID list). |
| `sellerIds` | string\[] | `[]` | Seller IDs to enrich directly. |

#### 📦 Product links (off by default)

| Field | Type | Default | Description |
|---|---|---|---|
| `enableProductLinks` | boolean | `false` | Find every seller offering specific products (brand protection, competitor monitoring). |
| `productUrls` | string\[] | `[]` | Product page URLs or ASINs. |
| `maxOffersPerProduct` | integer | `10` | Max sellers collected per product (up to 50). |

#### ⚙️ Collection & limits (shared)

| Field | Type | Default | Description |
|---|---|---|---|
| `country` | select | `US` | Marketplace country code (see list above). |
| `maxDepth` | integer | `10` | How deep to go into each keyword or category listing (safety cap). |
| `concurrency` | integer | `8` | How many sellers/products are processed in parallel (1–16). |
| `retries` | integer | `4` | How often each step is retried when the marketplace refuses or times out. |

#### 🎯 Lead details

| Field | Type | Default | Description |
|---|---|---|---|
| `enableLeadDetails` | boolean | `true` | Adds business name, address, phone, emails, feedback stats, and catalog size on every seller row. Every seller is exported even when no lead details are found. Adds a little extra time per seller. |
| `includeEmailsFromWebsites` | boolean | `false` | When a profile has no email, check the seller's own website for contact emails. Adds a little extra time per seller. Requires `enableLeadDetails`. |

#### 🔔 Webhook

| Field | Type | Default | Description |
|---|---|---|---|
| `webhookUrl` | string | `""` | Optional. Each seller is also POSTed to this URL the moment it is collected (see Webhooks). |
| `webhookFormat` | select | `json` | `json` (full record) or `slack` (Slack-friendly message payload). |

#### 🌐 Connection

| Field | Type | Default | Description |
|---|---|---|---|
| `proxyConfiguration` | proxy editor | Apify residential, US | Apify residential proxy is enabled by default. Change only if you need a different country or custom proxy URLs. |

#### Example inputs

**Keyword lead list (default source):**

```json
{
    "enableKeywordSearch": true,
    "keywords": "wireless earbuds, yoga mat",
    "maxSellersPerKeyword": 1000,
    "country": "US",
    "enableLeadDetails": true,
    "includeEmailsFromWebsites": true
}
```

**Category best sellers:**

```json
{
    "enableKeywordSearch": false,
    "enableCategoryRankings": true,
    "rankListType": "bestsellers",
    "category": "sports-and-outdoors",
    "maxSellersPerCategory": 500,
    "country": "GB"
}
```

**Enrich my own seller list:**

```json
{
    "enableKeywordSearch": false,
    "enableSellerList": true,
    "sellerIds": ["A1B2C3D4E5F6", "A6F5E4D3C2B1"],
    "country": "US",
    "enableLeadDetails": true
}
```

**Everyone selling my product:**

```json
{
    "enableKeywordSearch": false,
    "enableProductLinks": true,
    "productUrls": ["https://www.amazon.com/dp/B0EXAMPLE1"],
    "maxOffersPerProduct": 25,
    "country": "US"
}
```

**Two sources in one run** (each source exports up to its own cap — budgets add up):

```json
{
    "enableKeywordSearch": true,
    "keywords": "yoga mat",
    "maxSellersPerKeyword": 200,
    "enableProductLinks": true,
    "productUrls": ["B0EXAMPLE1"],
    "maxOffersPerProduct": 25
}
```

***

### Output schema (field-by-field)

One dataset row per seller, pushed the moment it is ready:

| Field | Type | Description |
|---|---|---|
| `sellerId` | string | Marketplace seller identifier (unique key). |
| `country` | string | Marketplace country code of this run. |
| `sellerUrl` | string | The seller's public profile URL. |
| `sellerName` | string | null | Display name of the seller. |
| `businessName` | string | null | Registered legal business name (lead detail). |
| `businessAddress` | string | null | Registered business address (lead detail). |
| `phone` | string | null | Contact phone from the profile (lead detail). |
| `emails` | array of string | All contact emails found for this seller (profile + website). |
| `website` | string | null | The seller's own website, when listed on the profile. |
| `websiteEmails` | array of string | Emails discovered on the seller's website (when enabled). |
| `positiveFeedbackPercent` | number | null | Positive feedback percentage. |
| `feedbackCount30d` | integer | null | Feedback events in the last 30 days. |
| `feedbackCount90d` | integer | null | Feedback events in the last 90 days. |
| `feedbackCount12m` | integer | null | Feedback events in the last 12 months. |
| `ratingsCount` | integer | null | Total feedback ratings. |
| `productCount` | integer | null | Total listings in the seller's catalog. |
| `products` | array of object | Up to three products this seller was discovered through (`asin`, `title`, `price`). |
| `foundVia` | string | The keyword, category, or list this seller came from. |
| `status` | string | `ok`, `not_found`, or `error`. |
| `notes` | string | null | Short human-readable note (e.g. "Email found on website"). |
| `scrapedAt` | string | ISO timestamp of when the seller was exported. |
| `position` | integer | 1-based export order in this run. |

Every run also stores a summary object under the **OUTPUT** key of the run's key-value
store: totals (exported / with email / with phone), products discovered, whether the items
limit was reached, and the `paywall` transparency object:

```json
{
    "paywall": {
        "detected": true,
        "isPaying": false,
        "pricingTier": "FREE",
        "limited": true,
        "blocked": false,
        "freeTierMaxItems": 2
    }
}
```

***

### Webhooks

Every seller is always saved to the run's dataset. A webhook is an **additional real-time
push**: each seller is POSTed to your URL the moment it is collected — perfect for piping
leads into a CRM while a long run is still going.

Setup:

1. Put your webhook URL into **Webhook URL** in the actor input.
2. Choose the **Webhook format**:
   - `json` — the full seller record (same shape as the dataset row).
   - `slack` — a Slack-friendly message payload for Slack incoming webhooks.
3. Start the run. Each POST has `Content-Type: application/json` and a single seller record
   as the body.

Delivery is best-effort: a slow or failing webhook never stops the run or blocks dataset
writes (a short note appears in the log instead). Webhook payloads contain only the
documented seller fields — nothing else.

Pair this with Apify platform webhooks (Actor → Settings → Webhooks) if you also want
run-level events (run finished, dataset ready) pushed elsewhere.

***

### MCP usage

This actor works with the Apify MCP Server, so AI agents (Claude, Cursor, etc.) can call it
as a tool:

1. In your MCP client, add the Apify MCP Server with your `APIFY_TOKEN`.
2. Expose this actor as a tool (actor name: `amazon-sellers-real-time-data-scraper`).
3. Ask naturally: *"Find 25 Amazon sellers in the wireless earbuds niche with their
   business details"* — the agent calls the actor with a sensible input and returns the
   dataset rows.
4. The input schema above is exactly the tool contract the agent uses; every field is
   optional — with defaults, the agent gets keyword search for 10 sellers, and it can turn
   on category rankings, seller lists, or product links by enabling those sections.

### Free tier vs paid plans

| | Free plan | Paid plan |
|---|---|---|
| Results per run | Sample capped (2 sellers) | Unlimited |
| Full enrichment | Sample only | Yes |
| Webhooks | Sample only | Yes |
| Support | Community | Priority |

Free runs exit gracefully with a clear message — they never fail. Owner-side tuning knobs
(environment variables on the actor, no code change needed):

- `FREE_TIER_MODE` — `limit` (default; cap results) or `block` (no results, upgrade message).
- `FREE_TIER_MAX_ITEMS` — results cap for free runs (default `2`).

### FAQ

**Is this actor allowed on the free Apify plan?**
Free accounts can test the actor but results are capped to a small sample per run. Upgrade
to a paid Apify plan for full, unlimited exports — the run log and run output both state
this clearly.

**Why do I get only 2 results?**
You are on a free Apify plan. The run is capped by policy, not by a bug. Upgrade to a paid
plan and rerun — no input changes needed.

**Do I need to filter results to get leads?**
No. The actor does not filter: with **Enable lead details** on, every seller is exported
with business name, address, phone, emails, website, feedback stats, and catalog size —
even if some fields come back empty. This keeps runtime per 1,000 sellers predictable.
Filter locally afterwards if you only want rows with emails.

**How fast is a run?**
Sellers are processed in parallel and streamed to the dataset as they finish. Expect
roughly a few hundred sellers per hour at default settings; increase `concurrency` for
faster runs. Lead details add a little extra time per seller.

**Which countries are supported?**
24 marketplaces: US, GB, DE, FR, IT, ES, CA, AU, IN, JP, MX, AE, NL, SE, PL, BE, SG, BR,
TR, SA, EG, ZA, IE, CN.

**Can I enrich sellers I already know?**
Yes — use the `seller-urls` or `seller-ids` source and provide your list; no discovery is
performed and each seller is enriched directly.

**Can I find everyone selling a specific product?**
Yes — use the `product-urls` source with product links or ASINs.

**How are emails found?**
Emails are collected from the seller's public profile when present. With "Find emails on
seller websites" enabled, the seller's own website is also checked for contact emails.
Only usable business emails are kept; service and noreply addresses are filtered out.

**Does it need cookies, logins, or browser automation?**
No login is required and the actor runs fully unattended. Just set your source and go.

**How do I get the data out?**
Download the dataset from the run page (JSON, JSONL, CSV, XLSX, XML) or call the dataset
API call shown in the run's Output tab. You can also stream each record to your own
service with the webhook input.

**Is the run resumable / can I stop it?**
You can abort at any time; everything already pushed stays in the dataset.

**Why did a run return fewer sellers than my "Max sellers" setting?**
Discovery stops when the source is exhausted — e.g. a rare keyword or a small category.
Raise `maxDepth`, add keywords, or widen the category.

**What does the `paywall` object in the output mean?**
Transparency: `detected` — platform plan status was readable; `isPaying` — the account is
on a paid plan; `pricingTier` — the account's tier; `limited` / `blocked` — how the free
tier was applied to this run.

# Actor input Schema

## `enableKeywordSearch` (type: `boolean`):

Discover sellers from marketplace search results for your keywords.

## `keywords` (type: `string`):

One or more search keywords, comma or newline separated. Example: "wireless earbuds, yoga mat".

## `maxSellersPerKeyword` (type: `integer`):

Maximum number of unique sellers to export from keyword search in this run.

## `enableCategoryRankings` (type: `boolean`):

Discover sellers from a category's best sellers, new releases, or movers & shakers list.

## `rankListType` (type: `string`):

Which ranking list to use.

## `category` (type: `string`):

Category path (e.g. "fashion", "sports-and-outdoors") or a numeric node id.

## `maxSellersPerCategory` (type: `integer`):

Maximum number of unique sellers to export from this ranking list.

## `enableListingUrls` (type: `boolean`):

Collect sellers directly from listing URLs you paste (any ranking or search listing).

## `categoryUrls` (type: `array`):

Full listing URLs to collect sellers from directly. The first URL is used per run.

## `maxSellersPerListing` (type: `integer`):

Maximum number of unique sellers to export from the listing URL.

## `enableSellerList` (type: `boolean`):

Enrich sellers you already know — no discovery, direct enrichment with business details and contacts.

## `sellerUrls` (type: `array`):

Seller profile URLs to enrich. Seller IDs from URLs and the ID list below are merged.

## `sellerIds` (type: `array`):

Seller IDs to enrich directly.

## `enableProductLinks` (type: `boolean`):

Find every seller offering specific products — ideal for brand protection and competitor monitoring.

## `productUrls` (type: `array`):

Product page URLs or ASINs.

## `maxOffersPerProduct` (type: `integer`):

Maximum sellers collected per product.

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

Amazon marketplace country code (US, GB, DE, FR, IT, ES, CA, AU, IN, JP, MX, ...).

## `maxDepth` (type: `integer`):

How deep to go into each keyword or category listing (safety cap for very large runs).

## `concurrency` (type: `integer`):

How many sellers/products are processed in parallel. Higher is faster; 8 is a good default.

## `retries` (type: `integer`):

How often each step is retried when the marketplace refuses or times out.

## `enableLeadDetails` (type: `boolean`):

Adds business name, address, phone, emails, feedback stats, and catalog size on every seller row. Every seller is exported even when no lead details are found — runtime stays predictable. Adds a little extra time per seller.

## `includeEmailsFromWebsites` (type: `boolean`):

When the seller profile has no email, check the seller's own website for contact emails. Adds a little extra time per seller. Only used when Enable lead details is on.

## `webhookUrl` (type: `string`):

Optional. Every seller is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new seller is also POSTed to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full seller object; slack = Slack-friendly message payload.

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

Apify residential proxy (US) is enabled by default for reliable collection.

## Actor input object example

```json
{
  "enableKeywordSearch": true,
  "keywords": "wireless earbuds",
  "maxSellersPerKeyword": 10,
  "enableCategoryRankings": false,
  "rankListType": "bestsellers",
  "category": "",
  "maxSellersPerCategory": 10,
  "enableListingUrls": false,
  "categoryUrls": [],
  "maxSellersPerListing": 10,
  "enableSellerList": false,
  "sellerUrls": [],
  "sellerIds": [],
  "enableProductLinks": false,
  "productUrls": [],
  "maxOffersPerProduct": 10,
  "country": "US",
  "maxDepth": 10,
  "concurrency": 8,
  "retries": 4,
  "enableLeadDetails": true,
  "includeEmailsFromWebsites": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every seller collected in this run.

## `withEmails` (type: `string`):

Sellers where at least one contact email was found.

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

Aggregate stats and paywall transparency object for this run (key-value store, OUTPUT key).

# 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 = {
    "enableKeywordSearch": true,
    "keywords": "wireless earbuds",
    "maxSellersPerKeyword": 10,
    "enableCategoryRankings": false,
    "category": "",
    "maxSellersPerCategory": 10,
    "enableListingUrls": false,
    "maxSellersPerListing": 10,
    "enableSellerList": false,
    "enableProductLinks": false,
    "maxOffersPerProduct": 10,
    "country": "US",
    "maxDepth": 10,
    "concurrency": 8,
    "retries": 4,
    "enableLeadDetails": true,
    "includeEmailsFromWebsites": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/amazon-sellers-real-time-data-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 = {
    "enableKeywordSearch": True,
    "keywords": "wireless earbuds",
    "maxSellersPerKeyword": 10,
    "enableCategoryRankings": False,
    "category": "",
    "maxSellersPerCategory": 10,
    "enableListingUrls": False,
    "maxSellersPerListing": 10,
    "enableSellerList": False,
    "enableProductLinks": False,
    "maxOffersPerProduct": 10,
    "country": "US",
    "maxDepth": 10,
    "concurrency": 8,
    "retries": 4,
    "enableLeadDetails": True,
    "includeEmailsFromWebsites": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/amazon-sellers-real-time-data-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 '{
  "enableKeywordSearch": true,
  "keywords": "wireless earbuds",
  "maxSellersPerKeyword": 10,
  "enableCategoryRankings": false,
  "category": "",
  "maxSellersPerCategory": 10,
  "enableListingUrls": false,
  "maxSellersPerListing": 10,
  "enableSellerList": false,
  "enableProductLinks": false,
  "maxOffersPerProduct": 10,
  "country": "US",
  "maxDepth": 10,
  "concurrency": 8,
  "retries": 4,
  "enableLeadDetails": true,
  "includeEmailsFromWebsites": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/amazon-sellers-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/amazon-sellers-real-time-data-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/mb4ZJ9dABLklDZygt/builds/Ypgc7YfLqCPEhoNTX/openapi.json