# Amazon Seller Feedback Records Scraper (`automation-lab/amazon-seller-feedback-records-scraper`) Actor

Export public Amazon seller feedback rows with ratings, comments, reviewers, dates, suppression reasons, seller replies, and reputation context across 15 marketplaces.

- **URL**: https://apify.com/automation-lab/amazon-seller-feedback-records-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Feedback Records Scraper

Export individual public Amazon seller feedback entries as clean, structured records.

Provide seller IDs or public `/sp?seller=...` profile URLs and receive one row per feedback entry with the star rating, comment, reviewer name, date, seller response, suppression signals, and seller reputation context.

This Actor is designed for repeatable seller reputation monitoring—not product reviews, catalog scraping, or private Seller Central data.

### What does Amazon Seller Feedback Records Scraper do?

Amazon Seller Feedback Records Scraper visits public Amazon seller profile pages and paginates through their public feedback feed.

It can:

- 📝 export individual seller feedback comments;
- ⭐ capture 1–5 star ratings and normalized sentiment;
- 👤 retain public reviewer names and profile links when available;
- 📅 preserve Amazon's displayed date and add an ISO date;
- 🛡️ identify feedback suppressed or struck through by Amazon;
- 💬 capture public seller responses when present;
- 📊 attach current seller reputation totals to every row;
- 🌍 process 15 Amazon marketplaces;
- 🔁 deduplicate rows with a deterministic feedback ID;
- 🎯 filter by stars, sentiment, date range, and suppression state.

The output is ready for spreadsheets, databases, BI tools, sentiment pipelines, and scheduled Apify automations.

### Who is it for?

#### Marketplace brands

Track how competing sellers perform on shipping, packaging, service, and order experience. Schedule daily or weekly exports to catch reputation changes early.

#### Aggregators and acquisition teams

Use recent negative feedback and rating trends as an additional due-diligence signal before evaluating a marketplace business.

#### Agencies

Monitor multiple seller IDs for clients without manually opening every Amazon profile. Deliver clean records to dashboards or Google Sheets.

#### Trust and safety teams

Review critical feedback, public suppression reasons, and seller responses as part of seller-risk investigations.

#### Wholesale buyers

Evaluate a supplier's recent fulfillment reputation before placing a large order or expanding a relationship.

#### Data and research teams

Build longitudinal seller-feedback datasets for sentiment analysis, benchmarking, or marketplace studies.

### Why use this Amazon seller feedback scraper?

Amazon seller feedback differs from Amazon product reviews. Seller feedback describes the order and seller experience: delivery, packaging, communication, fulfillment, and service.

Manually reviewing profiles is slow and difficult to repeat. This Actor provides:

- **Record-level data** instead of only aggregate seller percentages;
- **Consistent fields** across supported marketplaces;
- **Pagination** beyond the few recent rows visible on the first page;
- **Bulk input** for competitors, suppliers, or client portfolios;
- **Typed exports** through Dataset, API, CSV, JSON, Excel, and integrations;
- **Monitoring-ready IDs** for detecting new feedback between runs;
- **Cost control** with per-seller limits and conservative HTTP requests.

### What Amazon seller feedback data can I extract?

| Field | Description |
|---|---|
| `sellerId` | Amazon marketplace seller identifier |
| `sellerName` | Public seller display name |
| `marketplace` | Marketplace code such as `US`, `UK`, or `DE` |
| `marketplaceDomain` | Source Amazon domain |
| `marketplaceId` | Amazon marketplace identifier |
| `sellerUrl` | Public seller profile URL |
| `overallRating` | Current seller star rating |
| `positiveFeedbackPercent` | Public positive-feedback percentage |
| `ratings30Days` | Ratings in the last 30 days |
| `ratings90Days` | Ratings in the last 90 days |
| `ratings12Months` | Ratings in the last 12 months |
| `ratingsLifetime` | Lifetime public rating count |
| `feedbackId` | Deterministic deduplication ID |
| `rating` | Feedback star rating from 1 to 5 |
| `sentiment` | `positive`, `neutral`, or `negative` |
| `comment` | Public feedback comment |
| `reviewerName` | Public reviewer display name |
| `reviewerProfileUrl` | Public reviewer profile link when returned |
| `feedbackDate` | Date exactly as Amazon displays it |
| `feedbackDateIso` | Normalized `YYYY-MM-DD` date when parseable |
| `isSuppressed` | Whether Amazon suppressed or struck through the row |
| `suppressionReason` | Public reason shown by Amazon |
| `hasSellerResponse` | Whether the seller posted a response |
| `sellerResponse` | Public seller response text |
| `fulfillmentChannel` | Fulfillment signal returned by Amazon |
| `sourcePage` | Feedback page number |
| `scrapedAt` | UTC extraction timestamp |

Amazon may omit reviewer profiles, responses, suppression reasons, or other optional fields. Missing optional values are returned as `null` rather than invented.

### Supported Amazon marketplaces

The Actor supports bare seller IDs on these marketplaces:

- 🇺🇸 United States — amazon.com
- 🇨🇦 Canada — amazon.ca
- 🇲🇽 Mexico — amazon.com.mx
- 🇬🇧 United Kingdom — amazon.co.uk
- 🇩🇪 Germany — amazon.de
- 🇫🇷 France — amazon.fr
- 🇮🇹 Italy — amazon.it
- 🇪🇸 Spain — amazon.es
- 🇳🇱 Netherlands — amazon.nl
- 🇧🇪 Belgium — amazon.com.be
- 🇸🇪 Sweden — amazon.se
- 🇵🇱 Poland — amazon.pl
- 🇯🇵 Japan — amazon.co.jp
- 🇦🇺 Australia — amazon.com.au
- 🇸🇬 Singapore — amazon.sg

When you provide a complete seller profile URL, its Amazon domain overrides the default marketplace selector.

### How to scrape Amazon seller feedback

1. Open the Actor input page.
2. Add one or more Amazon seller IDs or `/sp?seller=...` URLs.
3. Choose the default marketplace for bare seller IDs.
4. Set the maximum feedback rows per seller.
5. Optionally select a star, sentiment, date range, or suppression filter.
6. Click **Start**.
7. Open the Dataset tab to preview, filter, or export the records.

For a cheap first run, keep the prefilled seller and five-row limit.

### Input parameters

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `sellerIds` | array | example seller | Seller IDs or seller profile URLs |
| `startUrls` | array | empty | Seller profile URLs via URL editor |
| `marketplace` | string | `US` | Marketplace for bare IDs |
| `maxFeedback` | integer | `25` | Maximum matching rows per seller |
| `starFilter` | string | `all` | Keep one star rating or all |
| `sentimentFilter` | string | `all` | Positive, neutral, negative, or all |
| `dateFrom` | string | empty | Inclusive lower date in `YYYY-MM-DD` |
| `dateTo` | string | empty | Inclusive upper date in `YYYY-MM-DD` |
| `includeSuppressed` | boolean | `true` | Keep publicly suppressed rows |
| `proxyConfiguration` | object | disabled | Optional Apify Proxy settings |
| `maxRequestRetries` | integer | `2` | Session rotations after blocked responses |

`maxFeedback` is applied per seller after filters. If you request 50 negative rows, the Actor may scan more than 50 source rows to find them.

### Input example

```json
{
  "sellerIds": [
    "A9U20DL23XRAV",
    "https://www.amazon.co.uk/sp?seller=EXAMPLE123"
  ],
  "marketplace": "US",
  "maxFeedback": 50,
  "sentimentFilter": "negative",
  "dateFrom": "2026-01-01",
  "includeSuppressed": true
}
````

The complete UK URL uses the UK marketplace even though the default is US.

### Output example

```json
{
  "sellerId": "A9U20DL23XRAV",
  "sellerName": "Hamilton Housewares International - FZCO",
  "marketplace": "US",
  "marketplaceDomain": "www.amazon.com",
  "marketplaceId": "ATVPDKIKX0DER",
  "overallRating": 4.8,
  "positiveFeedbackPercent": 94,
  "ratings12Months": 109,
  "ratingsLifetime": 544,
  "feedbackId": "d4ec2af0b3700f21f8298ce1",
  "rating": 5,
  "sentiment": "positive",
  "comment": "Excellent",
  "reviewerName": "ragia hegazi",
  "feedbackDate": "July 10, 2026",
  "feedbackDateIso": "2026-07-10",
  "isSuppressed": false,
  "hasSellerResponse": false,
  "sourcePage": 1,
  "sellerUrl": "https://www.amazon.com/sp?seller=A9U20DL23XRAV",
  "scrapedAt": "2026-07-15T00:00:00.000Z"
}
```

Optional fields can be `null` when Amazon does not publish them.

### Filtering seller feedback

#### Star rating

Choose one exact rating from 1 to 5. Use this when a workflow specifically needs one-star complaints or five-star praise.

#### Sentiment

The Actor follows Amazon's seller-feedback convention:

- **Positive:** 4 or 5 stars
- **Neutral:** 3 stars
- **Negative:** 1 or 2 stars

Do not combine a contradictory star and sentiment filter. For example, five stars plus negative sentiment produces no matching rows.

#### Date range

Use inclusive `dateFrom` and `dateTo` values in `YYYY-MM-DD` format. The raw Amazon date remains available in `feedbackDate`.

Localized dates that JavaScript cannot safely parse remain `null` in `feedbackDateIso`; they are retained rather than guessed.

#### Suppressed feedback

Amazon sometimes strikes through feedback and publishes a reason. Keep `includeSuppressed` enabled when studying moderation or fulfillment issues. Disable it when you only need feedback included in the seller's effective reputation.

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

This Actor uses pay-per-event pricing:

- a small one-time Actor start charge;
- one feedback-record event for every dataset row produced;
- automatic tier discounts for higher Apify plans.

The current configuration starts at **$0.005 per run** plus the feedback-record tier price shown on the Actor pricing tab. At the BRONZE rate of $0.000047624 per row, 1,000 rows cost about $0.0526 before higher-plan discounts.

You can control spend with `maxFeedback`, narrow date ranges, and focused seller lists. Runs that find fewer matching rows only charge for records actually saved, plus the start event.

Prices shown by Apify at run time are authoritative.

### Tips for reliable exports

- ✅ Use the seller ID from the `seller=` or `me=` parameter, not a storefront name.
- ✅ Match bare IDs to the correct marketplace.
- ✅ Prefer complete profile URLs when processing several domains.
- ✅ Start with 5–25 records while validating a new seller list.
- ✅ Schedule moderate batches instead of repeatedly scanning thousands of pages.
- ✅ Start with direct HTTP; enable SHADER or another Apify Proxy group only if Amazon blocks your runtime.
- ✅ Use the stable `feedbackId` to upsert data between scheduled runs.
- ⚠️ Amazon may publish no feedback for new or inactive sellers.
- ⚠️ A seller ID can be valid in one marketplace and absent in another.

### Reputation monitoring workflow

A practical scheduled monitor can:

1. Run once per day with a rolling `dateFrom`.
2. Export multiple competitor or supplier IDs.
3. Upsert rows by `feedbackId` into a database.
4. Alert when `sentiment` is `negative`.
5. Group comments by delivery, packaging, communication, or service topic.
6. Compare current `positiveFeedbackPercent` and `ratings12Months` over time.

Store the dataset from each run or connect an integration for automatic downstream processing.

### Integrations

#### Google Sheets

Use the Google Sheets integration to append new feedback records, then build seller-level pivot tables and trend charts.

#### Slack or email alerts

Connect an automation that filters negative rows and posts the seller name, rating, comment, and source URL to an operations channel.

#### Webhooks

Trigger a webhook after each run, fetch dataset items, and insert unseen `feedbackId` values into your application.

#### Databases and warehouses

Export JSON or CSV to PostgreSQL, BigQuery, Snowflake, S3, or another warehouse. `feedbackDateIso` and `scrapedAt` support time-series analysis.

#### Sentiment and LLM pipelines

Send `comment` and seller context to a classifier or LLM to identify themes, summarize recurring complaints, and prioritize supplier reviews.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-seller-feedback-records-scraper').call({
  sellerIds: ['A9U20DL23XRAV'],
  marketplace: 'US',
  maxFeedback: 25,
  sentimentFilter: 'all'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with the Apify API using Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-seller-feedback-records-scraper').call(run_input={
    'sellerIds': ['A9U20DL23XRAV'],
    'marketplace': 'US',
    'maxFeedback': 25,
    'sentimentFilter': 'negative',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-seller-feedback-records-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "sellerIds": ["A9U20DL23XRAV"],
    "marketplace": "US",
    "maxFeedback": 25
  }'
```

After the run succeeds, fetch items from its default dataset URL.

### Use Amazon seller feedback through MCP

Connect the Actor to AI assistants through the Apify MCP server.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/amazon-seller-feedback-records-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/amazon-seller-feedback-records-scraper"
    }
  }
}
```

Example prompts:

- “Export the 25 newest feedback entries for seller A9U20DL23XRAV on Amazon US.”
- “Find negative seller feedback since 2026-01-01 and summarize recurring delivery complaints.”
- “Compare recent feedback sentiment for these five Amazon seller profile URLs.”

### Scheduling and incremental collection

Use an Apify schedule for daily or weekly monitoring.

For incremental collection:

- keep a rolling `dateFrom` window to handle delayed or edited entries;
- upsert records using `feedbackId`;
- retain `scrapedAt` to track when each observation was collected;
- store reputation summary fields if you want rating-count history;
- avoid using reviewer name alone as an identifier.

A small overlap between runs is safer than a gap because deterministic IDs make duplicates easy to remove.

### Data quality and limitations

The Actor extracts what Amazon publishes on public seller pages.

Important limitations:

- Amazon can change page structure or apply anti-bot controls;
- deleted or private feedback cannot be recovered;
- reviewer profile and avatar fields are not always present;
- seller responses and suppression reasons are optional;
- localized date text may not always normalize to ISO safely;
- aggregate ratings can change after a record was collected;
- the feed does not provide private order IDs or buyer contact details;
- `maxFeedback` counts matching saved rows, not scanned source rows.

The Actor detects challenge and incomplete responses instead of returning fake empty records.

### Legality and responsible Amazon seller feedback scraping

Public web data can often be collected for legitimate purposes, but laws, contracts, and policies vary by jurisdiction and use case.

You are responsible for:

- complying with Amazon's terms and applicable laws;
- collecting only data you have a lawful reason to process;
- respecting privacy, intellectual property, and database rights;
- avoiding harassment, profiling, spam, or discriminatory decisions;
- setting reasonable schedules and request volumes;
- securing exported datasets and limiting retention.

This Actor does not bypass login, access private Seller Central information, or expose order identifiers.

### Troubleshooting

#### Why did the run say the seller profile was unusable?

Check that the seller ID belongs to the selected marketplace. If you copied a URL, include the full Amazon domain and `seller=` parameter. Keep Apify Proxy enabled if Amazon blocks your network route.

#### Why are there no matching rows?

The seller may have no public feedback, or your filters may exclude every row. Remove date, star, and sentiment filters and retry with a small limit.

#### Why is `feedbackDateIso` null?

Amazon returns localized human-readable dates. The Actor preserves the raw date but does not guess when the runtime cannot parse it safely.

#### Why do seller totals differ between runs?

Seller reputation totals are live aggregates. Amazon can add, remove, suppress, or recalculate feedback after an earlier run.

#### Can this scrape product reviews?

No. Seller feedback evaluates the seller/order experience. For product review text, use the related Amazon Reviews Scraper.

### FAQ

#### Can I use seller IDs instead of URLs?

Yes. Choose the marketplace and add each ID to `sellerIds`.

#### Can I process multiple marketplaces in one run?

Yes. Complete URLs are mapped by domain, so one input can contain US, UK, German, or other supported seller profile URLs.

#### Does it require an Amazon account?

No. V1 uses public seller profile and public feedback surfaces.

#### Does it export seller replies?

Yes, when Amazon includes a public response in the feedback record.

#### How are duplicate records handled?

The Actor hashes marketplace, seller, reviewer, date, rating, and comment into `feedbackId`, then skips repeats within the run.

#### What happens when Amazon returns a CAPTCHA?

The Actor detects the blocked response, rotates the proxy session, retries within the configured limit, and fails clearly if no seller profile can be reached.

### Related Amazon scrapers

- [Amazon Sellers Scraper](https://apify.com/automation-lab/amazon-sellers-scraper) — seller profiles and aggregate reputation data
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — individual product review records
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — product data and search results
- [Amazon Bestsellers Scraper](https://apify.com/automation-lab/amazon-bestsellers-scraper) — category bestseller rankings
- [Amazon Autocomplete Scraper](https://apify.com/automation-lab/amazon-autocomplete-scraper) — keyword suggestion research

Use this Actor when the required entity is an individual **seller feedback entry**, not a product, product review, or seller summary alone.

### Start exporting seller feedback

Add one seller ID, keep the five-row prefill, and run the Actor. Review the typed output in the Dataset tab, then expand the seller list or schedule the workflow once the fields match your monitoring needs.

# Actor input Schema

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

Add Amazon seller IDs (for example A9U20DL23XRAV) or complete /sp?seller= profile URLs. URL domains override the marketplace selector.

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

Optionally add Amazon /sp?seller= URLs with the URL list editor.

## `marketplace` (type: `string`):

Choose the marketplace used for bare seller IDs. A marketplace domain in a supplied URL takes precedence.

## `maxFeedback` (type: `integer`):

Stop after saving this many matching feedback entries for each seller.

## `starFilter` (type: `string`):

Keep all ratings or only feedback with one selected star rating.

## `sentimentFilter` (type: `string`):

Filter using Amazon's seller-feedback convention: positive is 4–5 stars, neutral is 3 stars, and negative is 1–2 stars.

## `dateFrom` (type: `string`):

Keep feedback on or after this date. Use YYYY-MM-DD; leave empty for no lower bound.

## `dateTo` (type: `string`):

Keep feedback on or before this date. Use YYYY-MM-DD; leave empty for no upper bound.

## `includeSuppressed` (type: `boolean`):

Include rows whose original feedback was struck through or suppressed by Amazon, retaining the public suppression reason.

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

Direct HTTP is the cheapest proven route. Enable Apify Proxy if Amazon blocks your runtime; SHADER is the first proxy group to try.

## `maxRequestRetries` (type: `integer`):

Rotate the session and retry a blocked seller profile up to this many times.

## Actor input object example

```json
{
  "sellerIds": [
    "A9U20DL23XRAV"
  ],
  "marketplace": "US",
  "maxFeedback": 5,
  "starFilter": "all",
  "sentimentFilter": "all",
  "includeSuppressed": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "sellerIds": [
        "A9U20DL23XRAV"
    ],
    "marketplace": "US",
    "maxFeedback": 5,
    "starFilter": "all",
    "sentimentFilter": "all",
    "includeSuppressed": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "maxRequestRetries": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-seller-feedback-records-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 = {
    "sellerIds": ["A9U20DL23XRAV"],
    "marketplace": "US",
    "maxFeedback": 5,
    "starFilter": "all",
    "sentimentFilter": "all",
    "includeSuppressed": True,
    "proxyConfiguration": { "useApifyProxy": False },
    "maxRequestRetries": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-seller-feedback-records-scraper").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 '{
  "sellerIds": [
    "A9U20DL23XRAV"
  ],
  "marketplace": "US",
  "maxFeedback": 5,
  "starFilter": "all",
  "sentimentFilter": "all",
  "includeSuppressed": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 2
}' |
apify call automation-lab/amazon-seller-feedback-records-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Seller Feedback Records Scraper",
        "description": "Export public Amazon seller feedback rows with ratings, comments, reviewers, dates, suppression reasons, seller replies, and reputation context across 15 marketplaces.",
        "version": "0.1",
        "x-build-id": "2gWfYWL9GxzDD1nmv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~amazon-seller-feedback-records-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-amazon-seller-feedback-records-scraper",
                "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/automation-lab~amazon-seller-feedback-records-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-amazon-seller-feedback-records-scraper",
                "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/automation-lab~amazon-seller-feedback-records-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-amazon-seller-feedback-records-scraper",
                "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": {
                    "sellerIds": {
                        "title": "Seller IDs or profile URLs",
                        "type": "array",
                        "description": "Add Amazon seller IDs (for example A9U20DL23XRAV) or complete /sp?seller= profile URLs. URL domains override the marketplace selector.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Seller profile URLs",
                        "type": "array",
                        "description": "Optionally add Amazon /sp?seller= URLs with the URL list editor.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "marketplace": {
                        "title": "Default Amazon marketplace",
                        "enum": [
                            "US",
                            "CA",
                            "MX",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "BE",
                            "SE",
                            "PL",
                            "JP",
                            "AU",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Choose the marketplace used for bare seller IDs. A marketplace domain in a supplied URL takes precedence.",
                        "default": "US"
                    },
                    "maxFeedback": {
                        "title": "Maximum feedback rows per seller",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after saving this many matching feedback entries for each seller.",
                        "default": 25
                    },
                    "starFilter": {
                        "title": "Star rating",
                        "enum": [
                            "all",
                            "5",
                            "4",
                            "3",
                            "2",
                            "1"
                        ],
                        "type": "string",
                        "description": "Keep all ratings or only feedback with one selected star rating.",
                        "default": "all"
                    },
                    "sentimentFilter": {
                        "title": "Sentiment",
                        "enum": [
                            "all",
                            "positive",
                            "neutral",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Filter using Amazon's seller-feedback convention: positive is 4–5 stars, neutral is 3 stars, and negative is 1–2 stars.",
                        "default": "all"
                    },
                    "dateFrom": {
                        "title": "Feedback date from",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep feedback on or after this date. Use YYYY-MM-DD; leave empty for no lower bound."
                    },
                    "dateTo": {
                        "title": "Feedback date to",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep feedback on or before this date. Use YYYY-MM-DD; leave empty for no upper bound."
                    },
                    "includeSuppressed": {
                        "title": "Include Amazon-suppressed feedback",
                        "type": "boolean",
                        "description": "Include rows whose original feedback was struck through or suppressed by Amazon, retaining the public suppression reason.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Direct HTTP is the cheapest proven route. Enable Apify Proxy if Amazon blocks your runtime; SHADER is the first proxy group to try.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Rotate the session and retry a blocked seller profile up to this many times.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```