# Amazon Seller Central Review Scraper & Monitor – Brand Reviews (`k-data-lab/amazon-seller-central-review-scraper`) Actor

Export and monitor every customer review from Seller Central's Brand Customer Reviews (Brand Registry) for US, EU (DE/IT/FR/ES/UK), JP and IN — with Order ID, photos and product rating. Schedule it with 'Only new reviews' to get each new review once. Sign in yourself in Live View.

- **URL**: https://apify.com/k-data-lab/amazon-seller-central-review-scraper.md
- **Developed by:** [K-Data Lab](https://apify.com/k-data-lab) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 reviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Seller Central Review Scraper & Monitor – Brand Customer Reviews (US · EU · JP · IN)

**Export every customer review of your brand from Seller Central's *Brand Customer Reviews* page into one clean table**, with the order ID, reviewer photos, product rating and review count, for **US, Germany, Italy, France, Spain, UK, Japan and India** in a single run. **Schedule it with *Only new reviews* on and it becomes a review monitor**: every run returns just the reviews that arrived since the last one, and you pay for each review once.

**Sign in once, yourself, in a real browser inside Apify's Live View**, and the actor remembers the session for later runs. No passwords in the input, no OTP relay, no copying cookies (cookie paste is still there as a fallback).

***

#### ⚠️ Read this first: Amazon's terms and your account

**Amazon's terms don't allow automated access to Seller Central** (robots, scrapers and similar tools). Using this actor may break those terms, and **Amazon can restrict or suspend a seller account it believes is accessed automatically**. You decide whether to use it, and **you run it at your own risk.** The publisher isn't responsible for any action Amazon takes on your account.

To keep the footprint small, the actor:

- reads only the Brand Customer Reviews page and the reviews API your own browser uses on it,
- scrapes **one region at a time at a human pace**, with random delays and scrolling,
- **backs off and retries** on throttling or robot checks (8 s → 25 s → 60 s), then **stops instead of hammering**,
- never changes anything in your account.

Keep runs small and infrequent (e.g. daily, with *Only reviews on/after*), and use Pace = HIGH for big exports. This isn't legal advice. If in doubt, ask Amazon or your counsel.

***

#### 🚀 Quick start (2 steps)

| Step | Mode | What you do |
|---|---|---|
| **1 · once** | 🔐 **Login** | Pick marketplaces → **Start** → open the run's **Live View** tab → sign in to Seller Central (email, password, 2-step code). The session is saved for each region. |
| **2 · every time** | 🔎 **Scrape** | Pick marketplaces → **Start**. Reviews come out as a table. Saved sessions are checked first and refreshed after each run. |

**Step 3 · optional, for monitoring:** turn on **Only new reviews** and add a daily **Schedule** (Apify Console → Schedules). Connect the dataset to Slack, email, Google Sheets or a webhook through Apify integrations to get new critical reviews pushed to your team.

When a session eventually expires, the run **stops that region with a clear message: "run Login mode again"**. It takes a minute.

***

#### 🔐 Login mode, step by step

1. In the input, set **Mode → 🔐 Login**, select your **Marketplaces**, and click **Start**.

2. Open the run's **Live View** tab. You'll see this:

   ![Login mode in Apify Live View](https://raw.githubusercontent.com/codingintheusa0402/spigen-gcx-automation/main/Scrapers/apify-sc-review-scraper/docs/login-live-view.png)

3. **Click inside the picture** to put the cursor in a field, type into the box above it, and press **Type** (or Enter). The 👁 button shows what you typed. Enter, Tab, ⌫, scroll, Back and Reload buttons are there too.

4. Sign in as usual: **email → password → 2-step code** (from your authenticator app or SMS). Tick **"Don't require OTP on this browser"** if Amazon offers it. Sessions then last longer.

5. If Seller Central shows **Select an account**, click your account and marketplace.

6. Make sure Seller Central is in **English** (language menu, top right). The scraper reads the English page.

7. Once you're on Seller Central, the actor **saves the session automatically** ("✅ US session saved") and opens the next region. Each region waits up to *Login mode: minutes to sign in* (default 10). **Skip region** moves on.

8. When the run finishes, switch **Mode → 🔎 Scrape** and run as often as you like.

**Which logins you need**

| Select any of… | Sign in to (one login each) | Notes |
|---|---|---|
| 🇺🇸 US | `sellercentral.amazon.com` | |
| 🇩🇪 DE · 🇮🇹 IT · 🇫🇷 FR · 🇪🇸 ES · 🇬🇧 UK | `sellercentral-europe.amazon.com` | **One Europe login covers all five.** The actor switches countries itself (DE → IT → FR → ES → UK). |
| 🇯🇵 JP | `sellercentral.amazon.co.jp` | The page often opens in Japanese. Switch to **English** before you finish. |
| 🇮🇳 IN | `sellercentral.amazon.in` | |

> 🔒 **Where sessions live:** in a named key-value store **in your own Apify account** (default `sc-review-sessions`, one record per region: `SESSION_US`, `SESSION_EU` …). Other users of this actor can't see it. **To forget a session**, delete that record or the whole store in Storage → Key-value stores, or sign out of all devices in Amazon. Your typing in Live View goes straight to the browser and is never stored or logged.

***

#### 🍪 Fallback: paste cookies instead

Prefer not to sign in through Live View? Paste a session per region into the secret **Cookie fallback** fields. They're stored encrypted by Apify and never logged. A pasted session wins over a saved one for that region, and after a successful run it's saved too, so you only paste once.

**Option A: Cookie-Editor (recommended)**

1. Install the free **Cookie-Editor** extension (Chrome / Edge / Firefox).
2. Sign in to Seller Central normally (in English) and open the region's Brand Customer Reviews page:
   - US: `https://sellercentral.amazon.com/brand-customer-reviews/`
   - Europe: `https://sellercentral-europe.amazon.com/brand-customer-reviews/`
   - Japan: `https://sellercentral.amazon.co.jp/brand-customer-reviews/`
   - India: `https://sellercentral.amazon.in/brand-customer-reviews/`
3. Click the Cookie-Editor icon → **Export** → **Export as JSON**. It's copied to your clipboard.
4. Paste it into that region's field (**US session**, **Europe session**, …).

**Option B: DevTools.** On the same page press **F12** → **Network** → reload → click the first `brand-customer-reviews/` request → **Request Headers** → right-click **cookie** → **Copy value** → paste.

Don't click **Sign out** in the browser you copied from. That ends the copied session immediately.

***

#### ♻️ Session health: checked at the start of every run

Before scraping, every region's session is tested with a single page view:

- **Healthy:** the region is scraped, then the **refreshed cookies are saved back** (*Keep saved sessions fresh*, on by default), so sessions live longer.
- **Expired:** that region **stops** with *"The US session has expired. Run the actor once in Login mode with US selected…"*. The other regions continue. If none is usable, the whole run stops with that message.
- Every run writes a **`SESSION_HEALTH`** report to its key-value store:
  - `OK`: scraped, with the review count
  - `SESSION_EXPIRED`: run **Login mode** for that region
  - `NO_SESSION`: no saved or pasted session for that region yet
  - `BLOCKED`: Amazon showed robot checks repeatedly. Wait a few hours and use Pace = HIGH.
  - `ERROR`: details in `message` (e.g. language not English, account name to pick)

Expired or missing sessions cost nothing beyond the run start.

***

#### 🔔 Review monitoring: only new reviews, billed once

Brand teams usually want *"what came in since yesterday?"*, not the same 1,500 reviews every morning. Turn on **Only new reviews (monitoring)**:

- The actor keeps a list of the Review IDs it has already delivered (record `SEEN_US`, `SEEN_DE` … in your session store, private to your account).
- Next run, those reviews are **skipped and not charged**. Paging stops at the first page with nothing new, so a daily run usually reads just one or two pages.
- The first run delivers everything in range once; after that, each run returns only new reviews.
- If a run hits your *Maximum cost per run*, the cut-off reviews aren't marked as delivered, so they come out in the next run.
- To start over (e.g. a full re-export), delete the `SEEN_<marketplace>` record, or just switch the option off for one run.

**Only reviews from the last N days** is a moving date window for schedules (e.g. `7`), so you never have to edit a fixed date again. Combine it with *Star ratings* `1,2,3` for a daily critical-review alert.

| Use case | Settings |
|---|---|
| Daily alert on new 1–3★ reviews | Only new reviews **on**, Star ratings `1,2,3`, schedule daily |
| Weekly report of all new reviews | Only new reviews **on**, schedule weekly |
| Rolling 30-day export | Only reviews from the last N days = `30` |
| One-off full history export | defaults, Max pages up to 400 |

***

#### 📥 Input example

```json
{
  "mode": "scrape",
  "marketplaces": ["US", "DE", "UK", "JP"],
  "maxPagesPerMarketplace": 30,
  "stars": [1, 2, 3],
  "onlyNewReviews": true,
  "reviewsFromDaysAgo": 30,
  "fetchOrderId": true,
  "accountEU": "Spigen EU"
}
```

#### 📤 Output columns

| Column | Example | Meaning |
|---|---|---|
| `ASIN` | `B0G7RYP439` | Child ASIN |
| `Created Date` | `2026-10-15` | Review date (yyyy-mm-dd) |
| `Has Photo` | `Y` / `N` | Review has photos (when photo fetch is on) |
| `Reviewer` | `Jane D.` | Public reviewer name |
| `Review Ratings` | `2` | Stars given |
| `Review Title` | `Stopped sticking after a week` | Title |
| `Review Text` | `…` | Review text |
| `Country` | `US` | Marketplace: US, DE, IT, FR, ES, UK, JP, IN |
| `Review Link` | `https://www.amazon.com/gp/customer-reviews/R…` | Public review link |
| `Image URL` | `https://m.media-amazon.com/images/I/…jpg\|…` | Photo URLs, `\|`-separated |
| `Review ID` | `R2ABCDEF123456` | Amazon review ID (unique key) |
| `Order ID` | `113-1234567-1234567` | Order ID of verified purchases |
| `Product Rating` | `4.2` | Product average rating |
| `Ratings Count` | `2958` | Product total ratings |

Building an integration? Set **Output field names → camelCase** to get `asin`, `createdDate`, `hasPhoto` … instead.

***

#### 💰 How much does it cost?

**From $3 per 1,000 reviews on the Free plan, $4–6 on paid plans.** It's pay-per-event, so platform usage isn't billed on top, and you're **charged only for review rows delivered**. Expired or missing sessions and failed regions cost nothing beyond the run start.

| Your Apify plan | Price per review | Per 1,000 reviews |
|---|---|---|
| 🎁 Free (try it on your monthly free credit) | $0.003 | **$3.00** |
| Starter | $0.006 | $6.00 |
| Scale | $0.005 | $5.00 |
| Business / Platinum / Diamond | $0.004 | $4.00 |

Plus **$0.01 per run** (browser start).

**Examples (Starter plan):** a daily incremental run of ~150 new reviews ≈ $0.91, a full export of 1,500 reviews × 4 marketplaces ≈ $36.01, and 🎁 the Free plan's monthly $5 credit covers **about 1,600 reviews** to test with, every month.

**Keep costs predictable:** set *Maximum cost per run* in the run options. The actor stops cleanly when it's reached, and it never bills past it.

***

#### 📸 Reviewer photos (optional)

Amazon shows review photos only to **signed-in shoppers**, and that's a different login from Seller Central. To fill `Has Photo` / `Image URL`:

1. Turn on **Fetch reviewer photo URLs**.
2. Sign in as a shopper on each store site you scrape (e.g. `www.amazon.com`, `www.amazon.de`), export with Cookie-Editor, and paste the export(s) into **Amazon shopper (storefront) session**. Several exports can be merged into one JSON array.

Without a shopper session, every review shows `Has Photo = N`.

***

#### ⚙️ Settings

| Setting | Default | Notes |
|---|---|---|
| Mode | Scrape | **Login** once to save sessions, then **Scrape** |
| Login mode: minutes to sign in | 10 | Per region |
| Max pages per marketplace | 30 | × page size = up to 1,500 newest reviews per marketplace |
| Reviews per page | 50 | 25 / 50 / 100 |
| Star ratings | 1–5 | `1,2,3` = critical reviews only |
| Only reviews on/after | — | Also stops paging early, so runs are faster |
| Only new reviews (monitoring) | off | Skips (and doesn't bill) reviews delivered by earlier runs |
| Only reviews from the last N days | — | Moving date window for schedules |
| ASIN filter | — | Keep only these child ASINs |
| Pace | MEDIUM | LOW = fastest, HIGH = safest for large or frequent runs. Retries with backoff are always on |
| Use sessions saved by Login mode | on | Off = only pasted sessions are used |
| Keep saved sessions fresh | on | Saves Amazon's rotated cookies after each successful region |
| Session store name | `sc-review-sessions` | One per brand / seller account |

#### 💡 Tips

- **Seller Central must be in English** (top-right language menu) when you sign in or copy the session. Review dates and reviewer names are read from the English page.
- **Schedule it daily** with *Only new reviews* on for a fast incremental export that bills each review once. The saved sessions refresh themselves after every successful run.
- Review IDs (and Order IDs) make the output easy to **deduplicate and append** into an existing sheet.

#### ❓ FAQ

**Does the actor get my password?** In Login mode you type it into Seller Central's own page through the Live View, like in any browser. The actor passes your keystrokes straight to the page and never stores or logs them. Only the resulting login cookies are saved, in your own account. With the cookie fallback, no password is involved at all.

**Will a daily schedule charge me again for old reviews?** Not with *Only new reviews* on. Already-delivered Review IDs are skipped before anything is billed.

**Why did a region return `SESSION_EXPIRED`?** Amazon ended that session (time, sign-out, or a new 2-step check). Run **Login mode** for that region again.

**Can several people / brands use it from one Apify account?** Yes. Give each seller account its own **Session store name** (e.g. `brand-a-sessions`).

**Can one Europe session scrape all EU countries?** Yes. DE, IT, FR, ES and UK are switched inside the same Seller Central Europe login.

**Is this the same data as Amazon's public review pages?** It's what Seller Central's Brand Customer Reviews shows the brand owner, plus Order IDs, which aren't public.

**Is it allowed?** See **Read this first** at the top. Amazon's terms don't allow automated access to Seller Central; you run this at your own risk.

🔖 **Tags:** seller central review export · brand customer reviews · amazon brand registry reviews · amazon review order id · amazon review monitoring · new amazon review alerts · amazon negative review tracker · seller central scraper · amazon eu reviews

# Actor input Schema

## `mode` (type: `string`):

First time? Choose <b>Login</b>, pick your marketplaces, start, then open the run's <b>Live View</b> tab and sign in to Seller Central yourself (email, password, 2-step code). The session is saved privately in your Apify account. After that, run in <b>Scrape</b> mode — no copying cookies.

## `marketplaces` (type: `array`):

Which Seller Central marketplaces to scrape. DE / IT / FR / ES / UK all use the one <b>Europe</b> session and are scraped one after another (DE → IT → FR → ES → UK).

## `loginTimeoutMinutes` (type: `integer`):

How long Login mode waits for you to finish signing in to each region before moving on.

## `sessionUS` (type: `string`):

<b>Optional — not needed if you used Login mode.</b> Fallback: Paste your logged-in Seller Central session for 🇺🇸 US (<code>sellercentral.amazon.com</code>). Easiest: install the free <b>Cookie-Editor</b> browser extension → open <code>https://sellercentral.amazon.com/brand-customer-reviews/</code> while logged in → Cookie-Editor → <b>Export → JSON</b> → paste here. A raw <code>Cookie:</code> request header copied from DevTools also works. ⚠️ Sessions expire — copy a fresh one before each scheduled run (at least every few days). Stored encrypted; never logged.

## `sessionEU` (type: `string`):

<b>Optional — not needed if you used Login mode.</b> Fallback: Paste your logged-in Seller Central session for 🇪🇺 Europe (<code>sellercentral-europe.amazon.com</code>). Easiest: install the free <b>Cookie-Editor</b> browser extension → open <code>https://sellercentral-europe.amazon.com/brand-customer-reviews/</code> while logged in → Cookie-Editor → <b>Export → JSON</b> → paste here. A raw <code>Cookie:</code> request header copied from DevTools also works. One Europe session covers DE, IT, FR, ES and UK. ⚠️ Sessions expire — copy a fresh one before each scheduled run (at least every few days). Stored encrypted; never logged.

## `sessionJP` (type: `string`):

<b>Optional — not needed if you used Login mode.</b> Fallback: Paste your logged-in Seller Central session for 🇯🇵 Japan (<code>sellercentral.amazon.co.jp</code>). Easiest: install the free <b>Cookie-Editor</b> browser extension → open <code>https://sellercentral.amazon.co.jp/brand-customer-reviews/</code> while logged in → Cookie-Editor → <b>Export → JSON</b> → paste here. A raw <code>Cookie:</code> request header copied from DevTools also works. ⚠️ Sessions expire — copy a fresh one before each scheduled run (at least every few days). Stored encrypted; never logged.

## `sessionIN` (type: `string`):

<b>Optional — not needed if you used Login mode.</b> Fallback: Paste your logged-in Seller Central session for 🇮🇳 India (<code>sellercentral.amazon.in</code>). Easiest: install the free <b>Cookie-Editor</b> browser extension → open <code>https://sellercentral.amazon.in/brand-customer-reviews/</code> while logged in → Cookie-Editor → <b>Export → JSON</b> → paste here. A raw <code>Cookie:</code> request header copied from DevTools also works. ⚠️ Sessions expire — copy a fresh one before each scheduled run (at least every few days). Stored encrypted; never logged.

## `maxPagesPerMarketplace` (type: `integer`):

Newest reviews first. Reviews per marketplace ≈ pages × page size (30 × 50 = 1,500). Stops early when reviews run out.

## `pageSize` (type: `integer`):

25, 50 or 100 (Seller Central page sizes).

## `stars` (type: `array`):

Only critical reviews: choose 1, 2, 3.

## `minReviewDate` (type: `string`):

Optional. Also stops paging early once pages are older than this date.

## `onlyNewReviews` (type: `boolean`):

For daily / hourly schedules: each review is delivered — and billed — <b>once</b>. The actor remembers the Review IDs it already returned (record <code>SEEN\_\<marketplace></code> in your session store) and skips them next time; paging also stops as soon as a page has nothing new, so repeat runs are fast and cheap. Delete that record to start over.

## `reviewsFromDaysAgo` (type: `integer`):

Optional relative window that moves with your schedule (e.g. 7 = the last week). Works like <i>Only reviews on/after</i>; if both are set, the later date wins. 0 or empty = off.

## `asinFilter` (type: `array`):

Optional. Keep only reviews of these ASINs (child ASINs).

## `fetchOrderId` (type: `boolean`):

Adds the Amazon order ID of verified-purchase reviews (from Seller Central's own reviews API, same session).

## `fetchImages` (type: `boolean`):

Fills Has Photo / Image URL. Needs an Amazon <b>shopper</b> session below (photos are only shown to signed-in shoppers).

## `storefrontSession` (type: `string`):

Only if Fetch photos is on: Cookie-Editor JSON exports from the Amazon store sites (e.g. www.amazon.com, www.amazon.de) while signed in as a shopper. You can paste several exports one after another inside one JSON array.

## `accountUS` (type: `string`):

e.g. 'Spigen Inc'

## `accountEU` (type: `string`):

e.g. 'Spigen EU'. Also used to switch between DE / IT / FR / ES / UK.

## `accountJP` (type: `string`):

e.g. 'Spigen 公式直営店'

## `accountIN` (type: `string`):

e.g. 'Spigen India'

## `outputFieldNames` (type: `string`):

Column names in the output.

## `detectionAvoidance` (type: `string`):

Delays and scrolling between pages. Every page load also retries with backoff (8s → 25s → 60s) on throttling or robot checks, and regions are scraped one after another.

## `returnRefreshedSessions` (type: `boolean`):

Amazon rotates session cookies while you browse. When on, the refreshed cookies are saved to this run's key-value store (record REFRESHED_SESSIONS, private to your account) so you can paste them into the next run and keep sessions alive longer.

## `useSavedSessions` (type: `boolean`):

Scrape mode reuses the sessions you saved with Login mode (when that region's paste field is empty).

## `saveSessions` (type: `boolean`):

After a successful region, the refreshed cookies (Amazon rotates them while you browse) are saved back, so sessions last longer. Pasted sessions are saved this way too, so next time you don't need to paste.

## `sessionStoreName` (type: `string`):

Named key-value store in YOUR Apify account that holds saved sessions (one record per region: SESSION_US, SESSION_EU …). Use a different name per brand / seller account. Delete the store to forget all sessions.

## Actor input object example

```json
{
  "mode": "scrape",
  "marketplaces": [
    "US"
  ],
  "loginTimeoutMinutes": 10,
  "maxPagesPerMarketplace": 30,
  "pageSize": 50,
  "stars": [
    "1",
    "2",
    "3",
    "4",
    "5"
  ],
  "onlyNewReviews": false,
  "fetchOrderId": true,
  "fetchImages": false,
  "outputFieldNames": "title",
  "detectionAvoidance": "MEDIUM",
  "returnRefreshedSessions": false,
  "useSavedSessions": true,
  "saveSessions": true,
  "sessionStoreName": "sc-review-sessions"
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `health` (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 = {
    "mode": "scrape",
    "marketplaces": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("k-data-lab/amazon-seller-central-review-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 = {
    "mode": "scrape",
    "marketplaces": ["US"],
}

# Run the Actor and wait for it to finish
run = client.actor("k-data-lab/amazon-seller-central-review-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "scrape",
  "marketplaces": [
    "US"
  ]
}' |
apify call k-data-lab/amazon-seller-central-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,k-data-lab/amazon-seller-central-review-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/94QvEGIwZP7pyczTt/builds/9v3Rm30VbjS5eM7W5/openapi.json