# Amazon Seller Data Extractor (`scrapapi/amazon-seller-data-extractor`) Actor

🛒 Amazon Seller Data Extractor collects public Amazon seller info—seller name, seller ID, store URL, rating, reviews, products, ASINs, prices & categories. ⚡ Fast, reliable, bulk & CSV/JSON export. 🔍 Ideal for market research, competitor analysis & lead gen.

- **URL**: https://apify.com/scrapapi/amazon-seller-data-extractor.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 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/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Seller Data Extractor

Amazon Seller Data Extractor is a fast, reliable Amazon seller data scraper that collects public seller information at scale — including seller IDs, storefront URLs, ratings, feedback, product links, and more. It solves the pain of manual lookups by turning ASINs, seller IDs, and seller URLs into structured records you can use for market research, competitor analysis, and lead generation. Built for marketers, developers, data analysts, and researchers, this Amazon seller information extractor enables bulk collection, clean exports, and automation-ready pipelines for large-scale insights. 🚀

### What data / output can you get?

Below are the exact JSON fields this Amazon seller storefront scraper produces and pushes to the Apify dataset. Each field reflects the live structure used by the actor.

| Data type | Description | Example value |
| --- | --- | --- |
| url | The seller or product page URL used for extraction | https://www.amazon.com/sp?seller=A33W53J5GVPZ8K |
| seller_id | Amazon seller ID parsed from URL or page | A33W53J5GVPZ8K |
| seller_name | Display name from the seller page (if present) | Peckomatic |
| description | “About Seller” text content | Peckomatic is committed to providing each customer with the highest standard of customer service. |
| detailed_info | Structured details like Business Name and Business Address | [{"title":"Business Name","value":"Francis Kunnumpurath"},{"title":"Business Address","value":"2612 state route 80, Lafayette, NY, 13084, US"}] |
| feedbacks | Parsed recent feedback entries with stars, text, and date | [{"stars":"5 out of 5 stars","text":"…","date":"By Kao y. on November 16, 2021."}] |
| stars | Overall seller rating text (if present) | 4.5 out of 5 stars |
| return_policy | Reserved for return policy data (currently an empty array) | [] |
| shipping_policies | Shipping policies paragraph (if present) | Ships all items within two days of receiving an order… |
| privacy_security | Privacy & security notice text (if present) | Amazon knows that you care how information about you is used and shared… |
| privacy_policy | Seller privacy policy content (if present) | Peckomatic values the privacy of your personal data. |
| help_content | Help/returns/refund contact text (if present) | For questions about a charge… |
| products_link | Direct link to seller’s product listings | https://www.amazon.com/s?ie=UTF8&marketplaceID=ATVPDKIKX0DER&me=A33W53J5GVPZ8K |
| rating_positive | Positive rating percentage summary (if present) | 88% positive |
| feedbacks_percentages | Star rating distribution (1–5) | {"star_5":"79%","star_4":"10%","star_3":"7%","star_2":"0%","star_1":"5%"} |
| rating_count_m12 | Ratings count (last 12 months, if present) | 0 |
| rating_count_m3 | Ratings count (last 3 months, if present) | 0 |
| rating_count_lifetime | Total lifetime ratings (if present) | 42 |
| rating_count_m1 | Ratings count (last 1 month, if present) | 0 |
| country | Marketplace country tag (default set) | US |
| timestamp | ISO timestamp of extraction | 2026-04-02T16:04:44.397Z |
| seller_phone_number | Seller phone number (reserved; null by default) | null |

Notes:
- Results are saved to the Apify dataset and can be downloaded in common formats like JSON, CSV, or Excel from the Apify platform.
- Some fields may be empty or null if not present on a specific seller page.

### Key features

- 🔗 Bold normalization for IDs & ASINs  
  Turn ASINs into product pages and auto-discover seller links. Convert seller IDs/usernames into normalized storefront URLs. This Amazon seller ID extractor streamlines input variability at scale.

- 🧵 Async engine with retry resilience  
  Uses aiohttp with exponential backoff and status-aware retries for robust scraping on Amazon. Designed for reliability across large batches.

- 🧠 Feedback collection with limits  
  Extracts public feedback entries and lets you cap the number with maxComments (0 = all). Ideal for controlling volume in bulk runs.

- 🌍 Marketplace/domain control  
  Choose your marketplace via amazonDomain (e.g., amazon.com, amazon.co.uk, amazon.de) and optionally pass language hints.

- 🛡 Residential proxies always-on  
  Automatically configures and uses Apify residential proxy for every run. Optionally pin a proxyCountry for geolocation needs. Stability without extra setup.

- 🧰 Bounded concurrency for safety  
  Control parallelism with maxConcurrency to balance speed and reduce the risk of blocks on Amazon.

- 💾 Structured dataset exports  
  Output is a well-structured, tabular JSON you can export from Apify as JSON/CSV/Excel for dashboards, CRMs, and analytics.

- 🧩 Developer-friendly workflows  
  Run on Apify, chain with APIs, and integrate the dataset into pipelines. Perfect for automation-driven Amazon seller data scraping software and research workflows.

- 📝 Transparent settings  
  Includes sortOrder and useCaptchaSolver inputs for compatibility. Note: keywordInputs are accepted but currently skipped (logged as “not yet fully implemented”).

### How to use Amazon Seller Data Extractor - step by step

1. Create or log in to your Apify account.  
2. Open the Amazon Seller Data Extractor actor in Apify.  
3. Add inputs:  
   - asinInputs: paste ASINs like B00P8XQPY4.  
   - usernameInputs: paste seller IDs like A33W53J5GVPZ8K.  
   - startUrls: paste seller URLs like https://www.amazon.com/sp?seller=A33W53J5GVPZ8K.  
   - keywordInputs: accepted but currently skipped (logged).  
4. Configure settings:  
   - amazonDomain to target a marketplace (e.g., amazon.com).  
   - language for page language hints (optional).  
   - proxyCountry to pin residential proxy location or keep AUTO.  
   - maxComments to limit collected feedbacks (0 = all).  
   - sortOrder (recent/helpful/rating) for future compatibility.  
   - maxConcurrency to tune speed and safety.  
5. Start the run. The actor will normalize inputs, fetch pages, and extract public seller data.  
6. Monitor logs for progress, retries, and any normalization notes.  
7. Download/export results from the run’s Dataset in JSON, CSV, or Excel.

Pro Tip: Use Apify’s API and scheduling to operationalize this Amazon marketplace seller data extractor in your data pipelines or enrichment workflows.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research + benchmarking | Aggregate ratings, reviews, and product links to quantify seller quality and category presence across marketplaces. |
| Competitor tracking for e‑commerce | Monitor competitor storefronts with this Amazon seller data scraping tool and analyze rating trends and feedback content. |
| Lead generation for vendors | Build a list of active sellers with IDs and product links using this Amazon seller leads extractor for outreach and enrichment. |
| Amazon FBA operations insight | Use the Amazon FBA seller data extractor to map sellers’ feedback profiles and prioritize partner/supplier evaluation. |
| Data enrichment for analytics | Feed structured seller profiles into BI tools and CRMs; export from the dataset as JSON/CSV/Excel. |
| API-driven pipelines | Run on a schedule, pull datasets via API, and power dashboards or alerts using this Amazon sellers database scraper. |
| Academic & policy research | Analyze public seller data distributions, feedback sentiment proxies, and marketplace dynamics across domains. |

### Why choose Amazon Seller Data Extractor?

Purpose-built for precision, automation, and reliability, this Amazon seller lookup scraper combines robust normalization, residential proxy stability, and clean JSON outputs.

- 🎯 Accurate field mapping: Extracts clearly defined fields (IDs, ratings, feedbacks, product links, policies) with a stable HTML parsing strategy.  
- 🌐 Marketplace-aware: Select your amazonDomain and optional language hints for multi-region coverage.  
- ⚡ Scalable & safe: Control throughput with maxConcurrency and benefit from built-in retries and residential proxies.  
- 👩‍💻 Developer-ready: Runs on Apify with dataset outputs and API access for easy downstream integration.  
- 🔒 Public data focus: Scrapes publicly available seller info without logins or cookies.  
- 💸 Cost‑effective automation: Cloud-native workflow reduces maintenance vs. ad-hoc scripts or browser extensions.  
- 🧱 Production-minded: Enforced residential proxies and retry logic offer higher resilience than unstable alternatives.

In short: a production-ready Amazon seller data scraper that prioritizes stability, structure, and scale.

### Is it legal / ethical to use Amazon Seller Data Extractor?

Yes — when used responsibly. This actor collects publicly available information from Amazon seller pages and does not access private or authenticated content.

Guidelines to follow:
- Scrape only public seller information and respect Amazon’s Terms of Service.  
- Ensure compliance with applicable data regulations (e.g., GDPR, CCPA).  
- Use outputs responsibly for permitted business purposes.  
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "asinInputs": ["B00P8XQPY4"],
  "usernameInputs": ["A33W53J5GVPZ8K"],
  "keywordInputs": [],
  "startUrls": [
    "https://www.amazon.com/sp?seller=A2N5Q13T20FFT2"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "useCaptchaSolver": false,
  "sortOrder": "recent",
  "maxComments": 10,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

| Parameter | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| asinInputs | array | No | \[] | List of Amazon ASINs (e.g., B00P8XQPY4). The actor will extract seller information from product pages. |
| usernameInputs | array | No | \[] | List of Amazon seller usernames or seller IDs (e.g., A33W53J5GVPZ8K). |
| keywordInputs | array | No | \[] | List of keywords to search for sellers. Note: currently logged as “not yet fully implemented” and skipped. |
| startUrls | array | No | \[] | List of Amazon seller page URLs (e.g., https://www.amazon.com/sp?seller=A33W53J5GVPZ8K). |
| amazonDomain | string | No | "amazon.com" | Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de). |
| language | string | No | "" | Language for Amazon pages (e.g., en-US, en-GB, de-DE). Leave empty for default. |
| proxyCountry | string | No | "AUTO" | Country for proxy selection. Use 'AUTO' for automatic selection. |
| useCaptchaSolver | boolean | No | false | Enable captcha solver (warning: may incur additional costs). Present for compatibility; not directly integrated in the current code path. |
| sortOrder | string | No | "recent" | Sort order for feedbacks (if applicable). Options: "recent", "helpful", "rating". |
| maxComments | integer | No | 10 | Maximum number of feedback comments to extract per seller (0 = all available). |
| maxConcurrency | integer | No | 10 | Maximum number of seller/product pages fetched in parallel. Lower values are safer for avoiding blocks and instability on Amazon. |
| proxyConfiguration | object | No | (none; prefill: {"useApifyProxy": false}) | Compatibility field. Note: The actor always uses residential proxy regardless of your selection and may add proxyCountry if set. |

Example JSON output

```json
{
  "url": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K",
  "seller_id": "A33W53J5GVPZ8K",
  "seller_name": "Peckomatic",
  "description": "Peckomatic is committed to providing each customer with the highest standard of customer service.",
  "detailed_info": [
    {
      "title": "Business Name",
      "value": "Francis Kunnumpurath"
    },
    {
      "title": "Business Address",
      "value": "2612 state route 80, Lafayette, NY, 13084, US"
    }
  ],
  "feedbacks": [
    {
      "stars": "5 out of 5 stars",
      "text": "It say not to exceed 10ths total but I did anyway...",
      "date": "By Kao y. on November 16, 2021."
    }
  ],
  "stars": "4.5 out of 5 stars",
  "return_policy": [],
  "shipping_policies": "Unless noted otherwise in the ordering pipeline, Peckomatic ships all items within two days of receiving an order...",
  "privacy_security": "Amazon knows that you care how information about you is used and shared...",
  "privacy_policy": "Peckomatic values the privacy of your personal data.",
  "help_content": "For questions about a charge that has been made to your credit card, please contact Amazon...",
  "products_link": "https://www.amazon.com/s?ie=UTF8&marketplaceID=ATVPDKIKX0DER&me=A33W53J5GVPZ8K",
  "rating_positive": "88% positive",
  "feedbacks_percentages": {
    "star_5": "79%",
    "star_4": "10%",
    "star_3": "7%",
    "star_2": "0%",
    "star_1": "5%"
  },
  "rating_count_m12": 0,
  "rating_count_m3": 0,
  "rating_count_lifetime": 42,
  "rating_count_m1": 0,
  "country": "US",
  "timestamp": "2026-04-02T16:04:44.397Z",
  "seller_phone_number": null
}
```

Notes:

- Some fields (e.g., seller\_name, stars, percentages) depend on page availability and may be empty.
- return\_policy is currently an empty array; seller\_phone\_number defaults to null.

### FAQ

#### Is there a free trial?

Yes. You can run the actor on Apify with a trial period/minutes depending on your plan and the actor’s pricing settings. Check the Apify listing to see current trial availability before subscribing.

#### Do I need to log in to Amazon?

No. The actor fetches publicly available seller and product pages without using Amazon logins or cookies.

#### Can I run it via API or integrate with Python?

Yes. As an Apify actor, it can be triggered via the Apify API, and results can be fetched programmatically to integrate with your pipelines or Python workflows.

#### Does it support multiple Amazon regions?

Yes. Set amazonDomain (e.g., amazon.com, amazon.co.uk, amazon.de) to target different marketplaces. You can also pass language hints via the language input.

#### Can it extract sellers starting from ASINs?

Yes. Provide ASINs in asinInputs and the actor will visit each product page, detect the seller link, and then scrape the seller’s storefront.

#### What about keyword-based discovery?

The actor accepts keywordInputs, but keyword search is not yet fully implemented in the current version. Keywords are logged and skipped so you retain a consistent configuration for future updates.

#### How does it handle CAPTCHAs and blocking?

The actor enforces residential proxies for every run and supports a proxyCountry pin for better locality. There is a useCaptchaSolver flag in the input, but the current code path does not directly integrate a solver; enabling it may incur additional costs if used in future-compatible setups.

#### What export formats are available?

Data is stored in the Apify dataset, from which you can export to JSON, CSV, or Excel. This makes it easy to power CRMs, dashboards, and analytics pipelines.

#### Is it suitable for Amazon FBA or seller lead lists?

Yes. As an Amazon seller list extractor and Amazon FBA seller data extractor, it’s ideal for building structured seller datasets, tracking feedback, and compiling product listing links for research and outreach.

### Closing thoughts

Amazon Seller Data Extractor is built to turn ASINs, seller IDs, and storefront URLs into clean, structured seller intelligence at scale. With enforced residential proxies, robust retries, and bounded concurrency, it delivers reliable extractions and ready-to-use datasets for marketers, developers, analysts, and researchers. Use the Apify API to automate runs, export datasets to your warehouse, and integrate this Amazon seller data scraping software into your enrichment workflows. Start extracting smarter seller insights today.

# Actor input Schema

## `asinInputs` (type: `array`):

List of Amazon ASINs (e.g., B00P8XQPY4). The actor will extract seller information from product pages.

## `usernameInputs` (type: `array`):

List of Amazon seller usernames or seller IDs (e.g., A33W53J5GVPZ8K).

## `keywordInputs` (type: `array`):

List of keywords to search for sellers (e.g., 'electronics seller', 'bookstore').

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

List of Amazon seller page URLs (e.g., https://www.amazon.com/sp?seller=A33W53J5GVPZ8K).

## `amazonDomain` (type: `string`):

Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de).

## `language` (type: `string`):

Language for Amazon pages (e.g., en-US, en-GB, de-DE). Leave empty for default.

## `proxyCountry` (type: `string`):

Country for proxy selection. Use 'AUTO' for automatic selection.

## `useCaptchaSolver` (type: `boolean`):

Enable captcha solver (warning: may incur additional costs).

## `sortOrder` (type: `string`):

Sort order for feedbacks (if applicable). Options: 'recent', 'helpful', 'rating'

## `maxComments` (type: `integer`):

Maximum number of feedback comments to extract per seller (0 = all available).

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

Maximum number of seller/product pages fetched in parallel. Lower values are safer for avoiding blocks and instability on Amazon.

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

Note: This actor always uses residential proxy regardless of your selection. The proxy configuration option is available for compatibility but will be automatically overridden to use residential proxy.

## Actor input object example

```json
{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "startUrls": [],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "useCaptchaSolver": false,
  "sortOrder": "recent",
  "maxComments": 10,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "asinInputs": [
        "B00P8XQPY4"
    ],
    "usernameInputs": [],
    "keywordInputs": [],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/amazon-seller-data-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 = {
    "asinInputs": ["B00P8XQPY4"],
    "usernameInputs": [],
    "keywordInputs": [],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/amazon-seller-data-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/amazon-seller-data-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapapi/amazon-seller-data-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Seller Data Extractor",
        "description": "🛒 Amazon Seller Data Extractor collects public Amazon seller info—seller name, seller ID, store URL, rating, reviews, products, ASINs, prices & categories. ⚡ Fast, reliable, bulk & CSV/JSON export. 🔍 Ideal for market research, competitor analysis & lead gen.",
        "version": "0.1",
        "x-build-id": "0MIcCztZ1w8FA6tAB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~amazon-seller-data-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-amazon-seller-data-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapapi~amazon-seller-data-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-amazon-seller-data-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapapi~amazon-seller-data-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-amazon-seller-data-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "asinInputs": {
                        "title": "Enter Amazon ASINs",
                        "type": "array",
                        "description": "List of Amazon ASINs (e.g., B00P8XQPY4). The actor will extract seller information from product pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernameInputs": {
                        "title": "Enter Seller Usernames",
                        "type": "array",
                        "description": "List of Amazon seller usernames or seller IDs (e.g., A33W53J5GVPZ8K).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordInputs": {
                        "title": "Enter Keywords",
                        "type": "array",
                        "description": "List of keywords to search for sellers (e.g., 'electronics seller', 'bookstore').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Amazon Seller URLs",
                        "type": "array",
                        "description": "List of Amazon seller page URLs (e.g., https://www.amazon.com/sp?seller=A33W53J5GVPZ8K).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "amazonDomain": {
                        "title": "Amazon domain",
                        "type": "string",
                        "description": "Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de).",
                        "default": "amazon.com"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for Amazon pages (e.g., en-US, en-GB, de-DE). Leave empty for default.",
                        "default": ""
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Country for proxy selection. Use 'AUTO' for automatic selection.",
                        "default": "AUTO"
                    },
                    "useCaptchaSolver": {
                        "title": "Use Captcha solver",
                        "type": "boolean",
                        "description": "Enable captcha solver (warning: may incur additional costs).",
                        "default": false
                    },
                    "sortOrder": {
                        "title": "Review sort order",
                        "enum": [
                            "recent",
                            "helpful",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for feedbacks (if applicable). Options: 'recent', 'helpful', 'rating'",
                        "default": "recent"
                    },
                    "maxComments": {
                        "title": "Maximum reviews per product",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of feedback comments to extract per seller (0 = all available).",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of seller/product pages fetched in parallel. Lower values are safer for avoiding blocks and instability on Amazon.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Note: This actor always uses residential proxy regardless of your selection. The proxy configuration option is available for compatibility but will be automatically overridden to use residential proxy."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```