# Amazon Product Lookup: amazon product scraper from $4/1k (`accountable_eel/amazon-product-lookup`) Actor

Amazon product scraper and ASIN lookup API. Paste ASINs or product links, get one flat row each: title, brand, price, currency, list price, rating, ratings count, availability, feature bullets, category, image and Best Sellers Rank, from six marketplaces. Never charged for a miss.

- **URL**: https://apify.com/accountable\_eel/amazon-product-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.04 / 1,000 product founds

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?

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 Product Lookup: amazon product scraper from $2/1k

You give this actor a list of Amazon ASINs or product links. For each one it fetches that
product's live detail page and returns a single flat row: title, brand, price and currency,
list price where the listing is discounted, star rating, ratings count, availability, the
feature bullets, the category breadcrumb, the main product image, and the Best Sellers Rank
line. It works across six marketplaces, amazon.com, amazon.de, amazon.co.uk, amazon.fr,
amazon.es and amazon.it, and a full product URL always keeps its own marketplace, so one run
can mix a US ASIN with a German one. Nothing is stored between runs: every row is read from
the page as it looked at fetch time.

### Who it's for

Ecommerce sellers and agencies who need to watch a competitor's catalogue without opening
forty browser tabs: price, availability and rank on the ASINs that matter, on whatever cadence
you schedule. Repricing and market research teams pulling a daily snapshot of a category's
top ASINs into a sheet or a warehouse table. Affiliate and content publishers refreshing the
price, image and star rating on product pages that would otherwise go stale. Brand protection
teams tracking whether their own ASINs are in stock, and at what price, on each European
marketplace. Retail analysts who want the Best Sellers Rank line for a set of ASINs over time.
And AI agents, which get a stable, flat, one row per ASIN shape over a plain HTTP endpoint,
with no pagination and no nested payload to unpick.

### Why this one

- **One row per ASIN, and the field names never move.** `asin`, `title`, `brand`, `price`,
  `currency`, `listPrice`, `rating`, `reviewCount`, `availability`, `bulletPoints`, `category`,
  `imageUrl`, `bestSellerRankText`, `productUrl`. Apify's MCP layer infers an actor's output
  shape from its recent runs, so a renamed field breaks every agent that calls it. These are
  frozen.
- **Never charged for a miss.** A dead ASIN, a bot check, or an input that is not an ASIN still
  produces a row with a `status` and a plain-English `message`, and costs nothing. See "Price"
  below for the found-row rate.
- **A missing price is reported as missing, not invented.** A discontinued listing with no buy
  box comes back with the title, rating, reviews and bullets it does have, and `price: null`.
  That is a real product row. Nothing on it is guessed.
- **Six marketplaces, mixable in one run.** Pick a marketplace for bare ASINs, or paste full
  product links and let each one carry its own. `marketplace` comes back on every row so you
  always know which storefront a price came from.
- **Both price layouts are handled.** Amazon serves the buy box as an embedded price JSON blob
  on some pages and as older accessibility markup on others, and both spellings of the decimal
  separator (`1,234.56` on .com and .co.uk, `1.234,56` on .de, .fr, .es and .it). All four
  combinations parse to the same number.
- **The list price is read from the buy box only.** A detail page carries dozens of struck
  through prices belonging to recommendation carousels. `listPrice` is scoped to this
  product's own price block, so it is either this ASIN's list price or `null`, never an
  accessory's.

### What you get

Every row starts with the same five fields, then adds the columns you selected in "Which
columns do you want?" (all included by default).

| Field | Type | Description |
|---|---|---|
| `query` | text | The ASIN or product link you submitted, echoed back |
| `found` | boolean | `true` if a product detail page was read for this input |
| `status` | text | `OK` on a hit; `NOT_FOUND`, `BLOCKED`, `BAD_FORMAT` or `REQUEST_FAILED` on a miss |
| `message` | text | Plain-English reason for a miss, present only when `found` is `false` |
| `scrapedAt` | ISO 8601 datetime | When the page was fetched |
| `asin` | text | The 10-character ASIN |
| `marketplace` | text | Which storefront the row came from: `com`, `de`, `co.uk`, `fr`, `es` or `it` |
| `title` | text | The product title as shown on the detail page |
| `brand` | text | Brand or store name from the byline under the title |
| `price` | number | Current buy box price as a plain number, or `null` when there is no buy box |
| `currency` | text | ISO currency code for `price`, read from the page itself |
| `listPrice` | number | The struck through list price, when the listing is discounted |
| `rating` | number | Star rating out of 5 |
| `reviewCount` | number | How many ratings the listing has |
| `availability` | text | The availability line, for example "In Stock" |
| `bulletPoints` | array | The feature bullets, in page order, up to 20 |
| `category` | text | Category breadcrumb, joined with `>` |
| `imageUrl` | link | Largest available main product image |
| `bestSellerRankText` | text | The Best Sellers Rank line as printed, for example "#332 in Home & Kitchen" |
| `productUrl` | link | Canonical product page for this ASIN on this marketplace |

Deselect any column in the Input tab to drop it from every row. `query`, `found`, `status`,
`message` and `scrapedAt` always stay.

### Price

$4 per 1,000 ASINs, plus a $0.00005 start fee. Misses (`found:false`) are never charged.

1,000 ASINs through this actor: **~$4** if every one is found, less if some are not. The
leading Amazon product scraper on the Store lists $5 per 1,000 products.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `asins` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~amazon-product-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"asins":["B00FLYWNYQ","B07FZ8S74R"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Paste your ASINs or product links into "ASINs or Amazon product URLs", one per line.
2) Pick the marketplace for bare ASINs. Full product links ignore this and keep their own.
3) Set the proxy country, under "Advanced", to that marketplace's country: US for amazon.com,
   Germany for amazon.de, and so on. Amazon prices a page for the delivery locale of the IP it
   sees, so a US proxy on amazon.com returns USD. The `currency` column always reports what the
   page actually showed, so a mismatch is visible rather than silent.
4) Leave "Try it first" on for the first run. It caps the run at 5 ASINs so you can see the
   output shape before spending on the full list.
5) Turn "Try it first" off and press Start to run the whole list.

Typical uses: a daily price and availability snapshot of a competitor's ASINs, refreshing
prices and images on an affiliate site, checking which of your own ASINs are in stock on each
European marketplace, or pulling the Best Sellers Rank line for a category's top sellers.

### Input

```json
{
  "asins": [
    "B00FLYWNYQ",
    "B07FZ8S74R"
  ]
}
```

One ASIN or product link per line. A link keeps its own marketplace, so you can mix amazon.com and amazon.de in the same list; a bare ASIN uses the marketplace you pick below. Accepted formats: B00FLYWNYQ, https://www.amazon.com/dp/B00FLYWNYQ, https://www.amazon.de/gp/product/B07FZ8S74R.

### Sample output

One row per ASIN:

| query | found | status | asin | marketplace | title | brand | price | currency | listPrice | rating | reviewCount | availability | bulletPoints | category | imageUrl | bestSellerRankText | productUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| B0CKKD1GXW | false | NOT\_FOUND | <asin> | <marketplace> | <product title> | <brand> | <price> | <currency> | \<list price (struck through)> | <star rating> | <ratings count> | <availability> | <feature bullets> | <category breadcrumb> | <main image> | <best sellers rank> | <product page> | 2026-09-08T17:43:18.595Z |

A real row from amazon.com:

| query | found | asin | title | brand | price | currency | rating | reviewCount | availability | bestSellerRankText |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| B00FLYWNYQ | true | B00FLYWNYQ | Instant Pot Duo 6 Qt 7-in-1 Electric Pressure Cooker, Stainless Steel | Instant Pot | 33611.05 | HUF | 4.7 | 180289 | In Stock | #332 in Home & Kitchen |

That row was captured without a proxy from a Hungarian exit IP, which is why the currency is
HUF. Set the proxy country to match the marketplace and the same ASIN returns USD.

An ASIN with no live listing, or a bot check, comes back as a row with `found: false` and a
`status` and `message` explaining which, and is never billed.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~amazon-product-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"asins":["B00FLYWNYQ","B07FZ8S74R"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~amazon-product-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"asins":["B00FLYWNYQ","B07FZ8S74R"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~amazon-product-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"asins":["{{ASIN}}"]}`, mapping the row's ASIN into the `asins` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Amazon Product Scraper: ASIN Lookup API | Apify" — the agent will find and run this actor.

### Tips

- Keep "Max concurrency" low. It defaults to 3 and caps at 10 on purpose: Amazon rate-limits
  by IP, and a burst that trips its bot check costs you retries and returns nothing, while a
  slower run gets the whole list.
- Set the proxy country to the marketplace's country. It is the single setting that decides
  which currency the prices come back in.
- Full product links are the safest input when your list spans marketplaces, because each link
  carries its own storefront and cannot be sent to the wrong one.
- An ASIN listed on amazon.com is not always listed on amazon.de. A `NOT_FOUND` on one
  marketplace and a row on another is normal, not a failure.
- Use "Hide rows with no result" when you are feeding a table that only wants live listings,
  and leave it off while you are still debugging an input list. Misses are free either way.
- `bestSellerRankText` is returned as Amazon prints it, including several ranks in one string.
  Parse it downstream rather than expecting a single number, because the shape differs by
  category and by marketplace language.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`amazon-product-lookup`) | $0.004 per found ASIN, $0.00005 actor start, nothing for a miss | One flat row per ASIN: title, brand, price, currency, list price, rating, ratings count, availability, feature bullets, category, image and Best Sellers Rank, on six marketplaces | Product detail pages only. It does not search, does not walk a category or seller listing, and does not return review text or offer-level seller data. Give it ASINs; it will not find them for you. |
| **junglee/Amazon-crawler** | $5 per 1,000 products | The broadest Amazon crawler on the Store, including search and category crawling rather than just detail pages, and 1,904 monthly users behind it | If you need to discover ASINs rather than look them up, that is the job it does and this one does not. It is rated 3.80 with an 8.6% run failure rate as of September 2026; this actor is narrower and charges nothing when a lookup returns nothing. |
| **Amazon Product Advertising API** | Free, but gated | The same catalogue data from Amazon directly, with offer and variation detail this cannot reach | It is the official source and it is better data. It also requires an Associates account in good standing with qualifying sales, and it is regional. If you have PA-API access, use it. This exists for everyone who cannot get it, or who wants six marketplaces without six sets of credentials. |
| Doing it yourself | Your time, plus a residential proxy budget and the maintenance | The same fields | Amazon serves two different price layouts, four decimal-separator and currency conventions, a captcha wall under load, and a page whose main image is not in the `src` attribute. Handling those, plus the retry and miss-classification logic, is what this absorbs. |

Prices and ratings for third-party tools are their published figures as of September 2026 and
are not tracked here. Check the vendor before relying on the comparison.

### FAQ

**Why is `price` null on a row that otherwise looks fine?**
The listing has no buy box: it is discontinued, temporarily unavailable, or sold only through
third-party offers. The rest of the row (title, brand, rating, reviews, bullets) is real and
is returned. A price is never guessed to fill the column.

**Why did I get a price in the wrong currency?**
Amazon prices a page for the delivery locale of the IP that requested it, not for the domain.
Set the proxy country under "Advanced" to the marketplace's country. The `currency` column
always reports what the page showed, so you can spot a mismatch immediately.

**Am I charged for a miss?**
No. The charge fires only when a product detail page was actually read. A dead ASIN, a bot
check, an input that is not an ASIN, and a failed request all produce a row (unless you turn on
"Hide rows with no result") and none of them cost anything.

**What does `BLOCKED` mean?**
Amazon served its bot check instead of the product page, or returned HTTP 403, 429 or 503.
Lower "Max concurrency", make sure the proxy group is set to Residential, and rerun. Blocked
rows are free, so a retry only costs the actor start.

**Can it search Amazon, or crawl a category or a seller?**
No. This is a lookup: ASINs in, one row each out. It has no search, no category walk and no
seller page crawl. If you need to discover ASINs, find them first and feed them here.

**Does it return review text?**
No. It returns the star rating and the ratings count from the detail page, not individual
reviews.

**Which marketplaces are supported?**
amazon.com, amazon.de, amazon.co.uk, amazon.fr, amazon.es and amazon.it. Bare ASINs use the
marketplace you pick in the Input tab; full product links always use their own.

**Is this a live read or a stored database?**
Live. Every run fetches the current detail page, so a price that changed an hour ago shows the
new one, and a listing that went out of stock shows that. Nothing is cached between runs.

**Can an AI agent call this directly?**
Yes. It is on the Apify MCP server, so an agent in Claude, Cursor or any MCP client can find
and run it by name, or you can call the REST endpoint above from any script or workflow tool.

**Is this GDPR-relevant?**
No personal data is involved. It reads a public product page: catalogue and pricing metadata
about a product, not information about any individual.

### Related actors

- [GTIN / Barcode Lookup](https://apify.com/accountable_eel/gtin-barcode-lookup): resolve an
  EAN, UPC or GTIN barcode to a product, brand and category from open product data.
- [Google Play App Lookup](https://apify.com/accountable_eel/google-play-app-lookup): the same
  one row per identifier shape for Android app listings.
- [Apple App Store Lookup](https://apify.com/accountable_eel/apple-app-store-lookup): app
  title, price, rating and ratings count from Apple's official lookup API.
- [Shopify Store Lookup](https://apify.com/accountable_eel/shopify-store-lookup): storefront
  and product detail for the same kind of catalogue work outside Amazon.

# Actor input Schema

## `asins` (type: `array`):

One ASIN or product link per line. A link keeps its own marketplace, so you can mix amazon.com and amazon.de in the same list; a bare ASIN uses the marketplace you pick below. Accepted formats: B00FLYWNYQ, https://www.amazon.com/dp/B00FLYWNYQ, https://www.amazon.de/gp/product/B07FZ8S74R. You're only charged for the ones we actually find — a miss costs nothing.

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

Applies to bare ASINs. A full product URL always keeps its own marketplace. Set the proxy country below to this marketplace's country so prices come back in its currency.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

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

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "asins": [
    "B00FLYWNYQ",
    "B07FZ8S74R"
  ],
  "marketplace": "com",
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "asin",
    "marketplace",
    "title",
    "brand",
    "price",
    "currency",
    "listPrice",
    "rating",
    "reviewCount",
    "availability",
    "bulletPoints",
    "category",
    "imageUrl",
    "bestSellerRankText",
    "productUrl"
  ],
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "asins": [
        "B00FLYWNYQ",
        "B07FZ8S74R"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/amazon-product-lookup").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 = {
    "asins": [
        "B00FLYWNYQ",
        "B07FZ8S74R",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/amazon-product-lookup").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 '{
  "asins": [
    "B00FLYWNYQ",
    "B07FZ8S74R"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/amazon-product-lookup --silent --output-dataset

```

## MCP server setup

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

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/kBHfNlMosfNuH8JQN/builds/9R2AB4fOjigNd9mgo/openapi.json