# Amazon MCP Server - Product Data for AI Agents (`mrbridge/amazon-mcp-server`) Actor

Amazon MCP server for Claude, ChatGPT and Cursor. Search products and read live prices, buy-box offers, public reviews and bestseller rankings across US, UK, French and German stores, with no Amazon API key. Not affiliated with Amazon. By MrBridge (mr-bridge.com)

- **URL**: https://apify.com/mrbridge/amazon-mcp-server.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** AI, E-commerce, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Amazon MCP Server

> **Status: public beta.** Five tools, live and tested end to end against real
> Amazon pages. Interfaces may still change between builds, and the
> [changelog](CHANGELOG.md) says what did.

**This project is not affiliated with, endorsed by, or sponsored by Amazon.**
"Amazon" is a trademark of Amazon.com, Inc. This is an independent tool that reads
publicly visible pages.

An [Apify Actor](https://apify.com/?fpr=mrbridge) running in Standby mode that
exposes public Amazon catalog data to AI agents through the Model Context Protocol.
Your assistant calls a tool, gets clean typed JSON back, and can reason over it
directly. It is a low-latency per-call data service, not a bulk exporter.

### Quick Start

In Claude Desktop, ChatGPT, Cursor, Windsurf, Claude Code, or another
MCP-compatible client, add this Streamable HTTP endpoint as a custom connector:

```
https://mrbridge--amazon-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

Replace `YOUR_APIFY_TOKEN` with your Apify API token. If your client can set
headers, send `Authorization: Bearer YOUR_APIFY_TOKEN` and use the bare `/mcp` URL
instead: a token in a query string ends up in logs and browser history.

The five tools appear once the Standby server starts. The first request after an
idle period takes a few seconds while the container wakes. Then ask your assistant
something like *"what does ASIN B08N5WRWNW cost on Amazon UK right now?"*

#### Or run it once, without a client

The Actor also accepts a conventional run. Fill in the Input form, start it, and it
performs a single read, writes one result to the dataset and finishes. Two
operations are available this way, `amazon_search` and `amazon_bestsellers`, which
is what makes the Actor usable as a saved Task or on a schedule.

Product, offers and reviews stay on the MCP endpoint. They bill per action, and
writing their results to the dataset would bill the same call a second time.

Prefer to read the HTTP contract directly? The Actor page renders an interactive
OpenAPI description of the endpoint, with request examples and documented
responses.

### Tools

| Tool | Input | Marketplaces | Returns |
|---|---|---|---|
| `amazon_search` | query, marketplace, page | US, UK, DE | products with ASIN, title, price, rating, image, URL |
| `amazon_product` | ASIN or product URL, marketplace | US, UK, FR, DE | title, brand, live price, availability, features, images, category, rating, buy-box seller |
| `amazon_offers` | ASIN, marketplace | US, UK, FR, DE | the buy-box offer: price, seller, availability |
| `amazon_reviews` | ASIN, marketplace | US, UK, FR, DE | publicly visible reviews, stripped of reviewer identity |
| `amazon_bestsellers` | category, marketplace | US, UK, FR, DE | ranked product list |

Marketplaces in v1: **US, UK, FR, DE**, with one exception. `amazon_search` is not
offered on FR. That is a measurement, not a policy: on 2026-08-01 amazon.fr answered
`/s` with an AWS WAF challenge while the product and best-seller pages came back
clean through the same proxy country, and five spaced searches on 2026-08-09 all
failed. Asking for it returns `UNSUPPORTED_MARKETPLACE` immediately, with no request
made and nothing charged. The other four tools read a product page or a ranking
page, so they work normally on FR.

The same coverage is published as a machine-readable MCP resource,
`amazon://marketplaces`, so a client can read it rather than trust this table.

Best sellers category slugs do not carry across storefronts. `electronics` resolves
on US, UK and FR, while the same department on DE is `ce-de`. A slug is not a
translation of its label either: the "Informatique" department on amazon.fr is
`computers`. Amazon serves an empty page rather than a 404 for a slug that does not
exist, which this server reports as `NOT_FOUND`.

Prices are marketplace-local and are never converted between currencies. Every response echoes back its marketplace, currency,
fetch timestamp, whether the data came from cache or from a live fetch, and whether
the call was charged. Every price you receive is fetched live: nothing that carries
a price is served from cache.

### What this server will not do

Being explicit about the limits is more useful than discovering them mid-session.

- **It does not solve CAPTCHAs.** When Amazon challenges every attempt, the tool
  returns a structured `BLOCKED_CAPTCHA` error and you are not charged.
- **It does not read anything behind a login.** Amazon serves its dedicated
  reviews page only to signed-in users, so reviews come from the ones displayed
  publicly on the product page, with a `reviewsTruncated` flag. There is no
  pagination, because there is no second page to read without signing in.
- **It returns one offer, not the whole market.** Amazon loads competing seller
  offers dynamically, behind a redirect. `amazon_offers` returns the buy-box offer
  and sets `offersTruncated`.
- **French coverage is partial, in one specific way.** Amazon France puts its
  search surface behind an AWS WAF challenge, so `amazon_search` is not offered on
  FR at all: it returns `UNSUPPORTED_MARKETPLACE` immediately, without fetching.
  It never returns `BLOCKED_CAPTCHA`, because no request is made. The other four
  tools read the product page or a ranking page, which answer normally on FR.
  Any fetch on any marketplace can still meet a challenge and come back as
  `BLOCKED_CAPTCHA`. You are not charged for either outcome.
- **It does not return reviewer identities.** Display names, profile links, avatars
  and badges are dropped before the data leaves the server. Each response lists
  what was removed in `redactedFields`.
- **It does not rehost images.** You get image URLs pointing at Amazon.
- **It does not run a browser.** Amazon's catalog pages are server-rendered, so a
  browser would add cost and latency for nothing.

### Errors are data, not crashes

A valid call that fails comes back as a structured tool error your agent can act
on: `INVALID_INPUT`, `NOT_FOUND`, `UNSUPPORTED_MARKETPLACE`, `BLOCKED_CAPTCHA`,
`RATE_LIMITED`, `GEO_MISMATCH`, `PARSE_ERROR`, `PROXY_ERROR`, `UPSTREAM_API_ERROR`,
`LOGIN_REQUIRED`. None of them is billed, and each one says whether retrying is
worth anything.

Arguments that are not valid in the first place are refused by MCP itself, with
`-32602`, before any of that runs. A wrong type, a number outside its range, a
string past its maximum length, a category that is not a plain slug, or a property
the tool does not declare all land there. Nothing is fetched and nothing is
charged. The two layers answer different questions: `-32602` means the call was
never well-formed, the taxonomy above means the call was fine and the world did not
cooperate.

`UNSUPPORTED_MARKETPLACE` is the one that never changes on a retry: the tool and
the storefront both exist, we just do not serve them together. Today that means
`amazon_search` on FR.

### Pricing

Pay-per-event. Every call falls into one of two categories, and each is billed once
per successful call that actually returned something:

- **Read Operation** covers `amazon_search` and `amazon_bestsellers`, which list a
  catalogue page.
- **Action Operation** covers `amazon_product`, `amazon_offers` and
  `amazon_reviews`, which each read a full product page.

A third event, **Actor Start**, is charged by Apify when the Standby container
starts. It is not a per-call charge and this server never fires it from code.

Nothing is charged for a failed call, a page Amazon blocked, invalid input, a tool
and marketplace combination this server does not serve, or an empty result. Every
response says which case it was in its `charged` field, and carries a `requestId`
that also appears on the billing receipt, so a charge can always be traced back to
the exact call that produced it.

**Platform usage is billed to you as well.** In the current configuration you pay
the per-event prices above plus your own Apify platform usage for the run, rather
than a single all-inclusive event price. Both appear on your Apify bill.

Current rates for all three events, across every plan tier, are on the
[Pricing tab](https://apify.com/mrbridge/amazon-mcp-server/pricing?fpr=mrbridge).
They are not repeated here: Apify renders them from the Actor's own configuration,
and a copy in this file would go stale the first time a price changes.

You can cap the spend of any run with `ACTOR_MAX_TOTAL_CHARGE_USD` from the Apify
Console. It bounds the total for the run across every event. Once the cap is
reached the server stops returning paid results rather than serving them free, so
the cap is a real ceiling.

### Connecting

In Claude Desktop, ChatGPT, Cursor, Windsurf, Claude Code, or another
MCP-compatible client, add this Streamable HTTP endpoint as a custom connector:

```
https://mrbridge--amazon-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

Replace `YOUR_APIFY_TOKEN` with your Apify API token. Clients that can set headers
should send the token as a bearer header instead and use the bare `/mcp` URL, which
keeps it out of logs and browser history.

The five Amazon tools become available once the Standby server starts. The first
request after an idle period may take a few seconds while the container wakes.

The Actor works two ways. As an MCP server it takes no run input and serves tool
calls on the endpoint above. As a conventional run it reads the Input form and
performs a single operation, `amazon_search` or `amazon_bestsellers`, writing one
result to the dataset and finishing. Product, offers and reviews are available on
the MCP endpoint only.

### FAQ

**Do I need an Amazon API key?**
No. There is no key to get: Amazon's Product Advertising API is affiliate-gated and
forbids this kind of use, which is why this server reads publicly visible pages
instead. Your Apify token is the only credential involved.

**Why did my first call take several seconds?**
Standby stops the container after five idle minutes. The next call wakes it, and
that one pays the cold start. Calls after it are fast until the next idle period.

**Why is `amazon_search` refused on FR when the other tools accept it?**
Amazon France guards its search surface specifically. The refusal is immediate and
free rather than a slow failure. See the coverage note above.

**Can I get all the offers for a product, not just the buy box?**
Not in v1. Amazon loads competing offers dynamically, so the server-rendered page
carries only the buy box. Responses say so with `offersTruncated: true`.

**Can I page through all the reviews?**
No. Amazon serves its paginated reviews page only to signed-in users, and this
server does not sign in. You get the reviews visible to anyone, with
`reviewsTruncated: true`.

**Are prices converted between marketplaces?**
Never. Every price is local to its storefront, and the response tells you which
currency it is in. Comparing across marketplaces is your conversion to make.

**Something is broken or a field stopped coming back. Where do I report it?**
Open an issue on the
[Issues tab](https://apify.com/mrbridge/amazon-mcp-server/issues?fpr=mrbridge).
Quote the `requestId` from the response: it ties your call to the server-side
record of it.

### More tools

Built by [Mr Bridge](https://mr-bridge.com). See also the
[MCP servers](https://mr-bridge.com/mcp-servers),
[scrapers](https://mr-bridge.com/scrapers), and
[AI workflows](https://mr-bridge.com/ai-workflows) catalogues.

# Actor input Schema

## `tool` (type: `string`):

Choose the Amazon read operation used by the saved Example. Amazon Search returns matching products, while Amazon Best Sellers returns a category ranking. Product details, offers, and reviews are available through the MCP connection.

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

Choose the Amazon storefront used for the request. The marketplace determines the catalog, currency, product URLs, and regional availability. Search supports US, UK, and DE; Best Sellers also supports FR.

## `query` (type: `string`):

Required when the operation is Search. Type it as a shopper would. Ignored for Best sellers.

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

Required when the operation is Best sellers. The slug or browse node id as it appears in /gp/bestsellers/{category}: letters, digits and hyphens only. Slugs differ per storefront, so "electronics" on US and FR is "ce-de" on DE. Ignored for Search.

## `page` (type: `integer`):

Search only. Result page to read, starting at 1.

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

Search only. Caps how many products come back.

## Actor input object example

```json
{
  "tool": "amazon_search",
  "marketplace": "US"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Every item this run produced. Use the view selector in the Console: Results for a conventional run, Billing receipts for a Standby run.

# 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 = {
    "tool": "amazon_search",
    "marketplace": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/amazon-mcp-server").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 = {
    "tool": "amazon_search",
    "marketplace": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/amazon-mcp-server").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 '{
  "tool": "amazon_search",
  "marketplace": "US"
}' |
apify call mrbridge/amazon-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

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/JwwMTeQ2T52BUYUOW/builds/4De0bVHsprxCZUB37/openapi.json