# Amazon Product Data, Reviews & Sellers (`antonio_cesar/amazon-data-suite`) Actor

Collect Amazon product details, Best Sellers, reviews, and seller profiles.

- **URL**: https://apify.com/antonio\_cesar/amazon-data-suite.md
- **Developed by:** [Antônio César](https://apify.com/antonio_cesar) (community)
- **Categories:** E-commerce, Integrations, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 single result in datasets

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/platform/actors/running/actors-in-store#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

### What does Amazon Scraper API: Products, Reviews & Sellers do?

**Amazon Scraper API: Products, Reviews & Sellers** collects live [Amazon](https://www.amazon.com/) search rankings, product details, Best Sellers, reviews, prices, ASINs, availability, and seller data. Enter keywords or Amazon URLs and receive normalized records ready for analysis in JSON, CSV, Excel, XML, RSS, or HTML—without managing browsers, proxies, or a separate data-provider API key.

All users can run the complete live workflow, regardless of their Apify subscription. Runs use predictable pay-per-result pricing. Apify provides API access, scheduling, integrations, monitoring, webhooks, and dataset storage around the Actor's managed data infrastructure.

**Unofficial — not affiliated with or endorsed by Amazon.** Amazon names and trademarks belong to their respective owners.

### Why use Amazon Scraper API?

- Track product prices, discounts, stock, ratings, and catalog changes.
- Compare organic and sponsored search placement across keywords.
- Discover products in Amazon Best Sellers categories.
- Analyze review themes and verified-purchase ratings while keeping reviewer identity private by default.
- Research Amazon US seller profiles and business information.
- Feed live commerce data into spreadsheets, dashboards, AI workflows, or your own application.
- Automate recurring research with Apify schedules and receive results through webhooks or integrations.

Every successful dataset item uses a stable envelope (`recordType`, `input`, `marketplace`, `sourceUrl`, and `scrapedAt`) plus fields for its selected operation. Item-level errors remain in the separate `ERRORS` record and are never mixed into the billable dataset.

### How to scrape Amazon data

1. Open the Actor's **Input** tab.
2. Choose Search, Product Details, Best Sellers, Product Reviews, or Seller Information.
3. Enter keywords or paste URLs that match the chosen operation.
4. Select the marketplace and set a small result limit for your first run.
5. Click **Start** and open the **Output** tab when the run finishes.
6. Download the dataset or connect it to your workflow through the Apify API, schedules, webhooks, Make, Zapier, or Google Sheets.

Invalid entries are reported individually. If a list contains both valid and invalid values, the Actor deduplicates the inputs, processes the valid ones, and records the rejected ones in `ERRORS`.

### Input

| Field | Used by | Description |
| --- | --- | --- |
| `operation` | All | `search`, `product_details`, `best_sellers`, `reviews`, or `seller_info`. Default: `search`. |
| `searchQueries` | Search | 1–20 unique keywords. |
| `marketplaceUrl` | Search | One of 22 supported Amazon marketplace roots. Product Details derives its marketplace from each URL. |
| `pagesToSearch` | Search | 1–5 pages per keyword. |
| `maxResults` | All | Total output cap for the entire run, not per keyword or URL. Default: 10. |
| `startUrls` | All URL operations | Product, ranking/category, or `/sp?seller=` URLs appropriate to the operation. |
| `zipcode`, `language` | Product, Best Sellers | Optional localization where supported. |
| `maxReviews` | Reviews | Per-product cap from 1 to 100. Default: 20. |
| `reviewsToNotInclude` | Reviews | Review IDs to omit during incremental collection. |
| `includeReviewerIdentity` | Reviews | Opt in to reviewer name/profile fields. Default: `false`. |
| `includeRawData` | All | Adds `rawData`; identity still requires the separate privacy opt-in. |
| `includeErrors` | All | Saves structured item errors in `ERRORS`. |
| `timeoutSeconds` | All | Absolute deadline covering trigger, retries, polling, and download. |

`variationSpecific` remains accepted for compatibility but is deprecated and is not sent upstream because the current Reviews contract does not document that filter.

Example keyword search:

```json
{
  "operation": "search",
  "searchQueries": ["wireless headphones"],
  "marketplaceUrl": "https://www.amazon.com",
  "pagesToSearch": 1,
  "maxResults": 5,
  "timeoutSeconds": 900
}
```

Example product-details run:

```json
{
  "operation": "product_details",
  "startUrls": [
    { "url": "https://www.amazon.de/dp/B0EXAMPLE" }
  ],
  "includeRawData": false
}
```

### Marketplace coverage

| Operation | Initial coverage | Run limits |
| --- | --- | --- |
| Search | US, Canada, Mexico, Brazil, UK, Germany, France, Italy, Spain, Netherlands, Belgium, Poland, Sweden, Türkiye, UAE, Saudi Arabia, Egypt, India, Singapore, Australia, Japan, and China | 20 keywords, 100 results per keyword, 1,000 total |
| Product Details | The same 22 marketplaces | 500 product URLs |
| Product Reviews | Amazon US (`amazon.com`) | 100 products, 100 reviews per product, 1,000 results total in this general Actor |
| Best Sellers | Amazon US (`amazon.com`) | 20 category URLs, 500 results total |
| Seller Information | Amazon US (`amazon.com`) | 500 seller URLs |

Selecting an unsupported marketplace/operation combination fails early with a clear validation error, before a collection job is purchased.

### Output

Successful records are stored in the default dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. `OUTPUT` contains the run status and exact requested, successful, failed, and charged counts; `ERRORS` contains sanitized item-level failures.

Representative search item:

```json
{
  "recordType": "search",
  "input": "wireless headphones",
  "marketplace": "https://www.amazon.com",
  "sourceUrl": "https://www.amazon.com/dp/B0EXAMPLE1",
  "scrapedAt": "2026-08-21T12:00:00Z",
  "keyword": "wireless headphones",
  "position": 1,
  "sponsored": false,
  "asin": "B0EXAMPLE1",
  "title": "Example product title",
  "finalPrice": 39.99,
  "currency": "USD",
  "rating": 4.6,
  "reviewsCount": 12450,
  "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/example.jpg"
}
```

Representative review item with the default privacy settings:

```json
{
  "recordType": "reviews",
  "input": "https://www.amazon.com/dp/B0EXAMPLE1",
  "marketplace": "https://www.amazon.com",
  "sourceUrl": "https://www.amazon.com/dp/B0EXAMPLE1",
  "scrapedAt": "2026-08-21T12:00:00Z",
  "asin": "B0EXAMPLE1",
  "reviewId": "R1EXAMPLE",
  "reviewTitle": "Representative review title",
  "reviewText": "Representative review text.",
  "rating": 5,
  "verifiedPurchase": true
}
```

The values above illustrate the normalized contract; use **Try for free** to collect current live records from your own inputs.

### Data table

| Data group | Main normalized fields |
| --- | --- |
| Common envelope | `recordType`, `input`, `marketplace`, `sourceUrl`, `scrapedAt` |
| Search | `keyword`, `position`, `sponsored`, `asin`, `title`, `finalPrice`, `rating`, `reviewsCount` |
| Products | `brand`, `parentAsin`, `availability`, `delivery`, `categories`, `bulletPoints`, `specifications`, `images` |
| Reviews | `reviewId`, `reviewTitle`, `reviewText`, `reviewDate`, `rating`, `verifiedPurchase`, `variation` |
| Sellers | `sellerId`, `sellerName`, `businessName`, `businessAddress`, `rating`, `reviewsCount` |

Field availability depends on the operation, marketplace, page, inventory state, and Amazon's current presentation. Enable `includeRawData` only when you need additional upstream fields because it increases output size.

### API examples

Replace `<ACTOR_ID>` with the Actor ID and keep your Apify token in an environment variable.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"operation":"search","searchQueries":["wireless headphones"],"maxResults":5}'
```

#### Python

```python
import os
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items",
    params={"token": os.environ["APIFY_TOKEN"]},
    json={
        "operation": "search",
        "searchQueries": ["wireless headphones"],
        "maxResults": 5,
    },
    timeout=1000,
)
response.raise_for_status()
items = response.json()
```

#### JavaScript

```javascript
const response = await fetch(
  `https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=${process.env.APIFY_TOKEN}`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      operation: 'search',
      searchQueries: ['wireless headphones'],
      maxResults: 5,
    }),
  },
);

if (!response.ok) throw new Error(`Actor run failed: ${response.status}`);
const items = await response.json();
```

### Focused Amazon scraper APIs

Prefer a smaller form and a dataset dedicated to one workflow? The same tested collection core also powers these focused Actors:

| Workflow | Focused Actor |
| --- | --- |
| Product catalogs, prices, and availability | [Amazon Product Scraper API](https://apify.com/antonio_cesar/amazon-product-scraper-api) |
| Keyword rankings and sponsored results | [Amazon Search Scraper API](https://apify.com/antonio_cesar/amazon-search-scraper-api) |
| Review and sentiment datasets | [Amazon Reviews Scraper API](https://apify.com/antonio_cesar/amazon-reviews-scraper-api) |
| Category rankings | [Amazon Best Sellers Scraper API](https://apify.com/antonio_cesar/amazon-best-sellers-scraper-api) |
| Seller research | [Amazon Seller Scraper API](https://apify.com/antonio_cesar/amazon-seller-scraper-api) |

The focused Actors use the same normalized output envelope and separate item errors from billable dataset results.

### How much does it cost to scrape Amazon?

The launch price is **US$0.004 per successful result**, or **US$4 per 1,000 results**, with the Actor's platform usage included. The Actor applies billing limits before starting managed collection and writes errors outside the paid dataset. The Actor's **Pricing** tab is always the authoritative source if pricing changes.

| Successful results | Estimated price |
| ---: | ---: |
| 5 | US$0.02 before any available free Apify credits |
| 100 | US$0.40 |
| 1,000 | US$4.00 |

Free-plan and paid users can request results up to the operation maximum and their available run budget. A run with no successful result has no per-result charge, although the Pricing tab should be checked for any platform-specific terms.

### Tips and advanced options

- Start with one keyword or URL and five results to verify the output contract.
- Remember that `maxResults` is a global run cap, while `maxReviews` applies to each product.
- Split operations into separate scheduled runs so each downstream dataset has one record type.
- Use `reviewsToNotInclude` to avoid requesting known review IDs again.
- Leave reviewer identity disabled unless your use case has a lawful need for it.
- Use a postal code when local delivery, availability, or price matters.
- Set an explicit deadline for automated workflows; the Actor attempts to cancel active external jobs on timeout or abort.
- Inspect `OUTPUT` and `ERRORS` before retrying a partial run.

#### Share one `.env` across all Amazon Actors

Use `scripts/sync_amazon_env.py` to make the root `.env` the single source for shared Actor credentials. The script stores each value once in the local Apify CLI secret store and writes only `@secretName` references to Actor manifests; it never copies `.env` into Actor folders or prints secret values.

```powershell
## Preview the variables and Actors without changing anything
.\.venv\Scripts\python.exe scripts\sync_amazon_env.py

## Update the shared local secrets and manifest references
.\.venv\Scripts\python.exe scripts\sync_amazon_env.py --apply

## Update and publish the main Actor plus all five specialized Actors
.\.venv\Scripts\python.exe scripts\sync_amazon_env.py --apply --push
```

Add `--specialized-only` to exclude `amazon-data-suite`. Bright Data aliases such as `BRIGHTDATA_API_TOKEN` are normalized to the shared `BRIGHTDATA_API_TOKENS` Actor variable. `APIFY_TOKEN` and `APIFY_API_TOKEN` are rejected to prevent platform credentials from being injected into Actor containers.

### FAQ, disclaimers, and support

#### Is this an official Amazon product?

No. **Unofficial — not affiliated with or endorsed by Amazon.** Amazon names and trademarks belong to their respective owners.

#### Does the free trial return real data?

Yes. Free-plan users receive live results up to the configured operation and billing limits, subject to available Apify credits and the current Pricing tab. The Actor does not insert mock records into the dataset.

#### Is scraping Amazon legal?

Web-scraping rules vary by jurisdiction and use case. You are responsible for complying with applicable law, Amazon's terms, privacy obligations, intellectual-property rights, and restrictions governing the collected data. Do not collect or use prohibited, private, or sensitive personal data.

#### Why can fields be missing?

Amazon pages differ by marketplace, product type, seller, inventory, localization, and current page structure. Optional fields are `null` or absent when the source does not provide them. See `ERRORS` for rejected inputs and upstream failures.

#### Where can I get help?

Use the Actor's **Issues** tab and include the run ID, operation, expected behavior, and a public example URL. Never post tokens or private data. Custom integrations, larger workflows, and tailored output contracts are available on request.

# Actor input Schema

## `operation` (type: `string`):

Select the Amazon data you want to collect.

## `searchQueries` (type: `array`):

Enter 1–20 unique product keywords, such as wireless headphones or PS5 accessories.

## `marketplaceUrl` (type: `string`):

Marketplace root used by Search. Product Details derives the marketplace from each URL; Reviews, Best Sellers, and Seller Information currently require Amazon.com.

## `pagesToSearch` (type: `integer`):

Inspect 1–5 search pages per keyword. maxResults still limits the combined output from the entire run.

## `maxResults` (type: `integer`):

Maximum number of records returned by the entire run. Search supports up to 1,000 and Best Sellers up to 500; the runtime also respects the available billing budget.

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

Use product URLs for details/reviews, ranking or category URLs for Best Sellers, or /sp?seller= URLs for sellers. Product/Seller accept up to 500, Reviews up to 100, and Best Sellers up to 20.

## `zipcode` (type: `string`):

Optional postal code used for localized availability, delivery, and price data.

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

Language locale for Product Details. Choose Automatic to use the marketplace default.

## `maxReviews` (type: `integer`):

Maximum reviews returned for each product URL. The limit is applied as an upstream per-input result cap.

## `variationSpecific` (type: `boolean`):

Deprecated compatibility field. It is accepted but no longer sent upstream because the current Reviews API does not document this filter.

## `reviewsToNotInclude` (type: `array`):

Optional unique review IDs to omit from incremental collection.

## `includeReviewerIdentity` (type: `boolean`):

Include reviewer name, profile URL, and identifiers when available. Disabled by default for privacy; you are responsible for lawful use.

## `includeRawData` (type: `boolean`):

Add rawData to each result. Reviewer identity remains removed unless Include reviewer identity fields is also enabled.

## `includeErrors` (type: `boolean`):

Save validation and upstream item errors to the ERRORS key-value record. Errors are never written to the billable results dataset.

## `timeoutSeconds` (type: `integer`):

Maximum elapsed time for trigger, polling, retries, and download. Active external snapshots are cancelled when this deadline expires.

## Actor input object example

```json
{
  "operation": "search",
  "searchQueries": [
    "wireless headphones"
  ],
  "marketplaceUrl": "https://www.amazon.com",
  "pagesToSearch": 1,
  "maxResults": 10,
  "zipcode": "",
  "language": "",
  "maxReviews": 20,
  "variationSpecific": false,
  "reviewsToNotInclude": [],
  "includeReviewerIdentity": false,
  "includeRawData": false,
  "includeErrors": true,
  "timeoutSeconds": 900
}
```

# Actor output Schema

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

Successful normalized Amazon records. Validation and upstream errors are never mixed into this billable dataset.

## `summary` (type: `string`):

Live or final run status with requested, successful, failed, and charged counts.

## `errors` (type: `string`):

Structured validation or upstream errors, kept outside the results 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 = {
    "searchQueries": [
        "wireless headphones"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("antonio_cesar/amazon-data-suite").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 = { "searchQueries": ["wireless headphones"] }

# Run the Actor and wait for it to finish
run = client.actor("antonio_cesar/amazon-data-suite").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 '{
  "searchQueries": [
    "wireless headphones"
  ]
}' |
apify call antonio_cesar/amazon-data-suite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,antonio_cesar/amazon-data-suite"
        }
    }
}

```

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/7id46W6r2oNE9msOy/builds/Uqbq1ybnfxkdjubGF/openapi.json