# Amazon ASIN Product Details Scraper (`johnatan029/amazon-asin-product-details-scraper`) Actor

Extracts structured public product details from Amazon ASINs and product URLs across US, UK, DE, CA, FR, IT, and ES with per-item statuses and quality metrics. No login.

- **URL**: https://apify.com/johnatan029/amazon-asin-product-details-scraper.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 ASIN Product Details Scraper

Extract structured public product details from ASINs and Amazon product URLs across US, UK, DE, CA, FR, IT, and ES. Every accepted item is correlated with its input and receives an explicit `FOUND`, `PARTIAL`, `NOT_FOUND`, `INVALID_INPUT`, `BLOCKED`, or `FAILED` status.

The Actor does not log in, collect individual reviews, visit `/product-reviews/`, invent missing values, or require an Amazon API key.

### Input

```json
{
  "marketplace": "US",
  "asins": ["B09X7MPX8L"],
  "productUrls": ["https://www.amazon.com/dp/B0CL61F39H"],
  "includeNotFound": true,
  "maxConcurrency": 2,
  "maxBrowserFallbacks": 1,
  "proxyConfiguration": { "useApifyProxy": true },
  "debug": false
}
```

- `marketplace`: default marketplace for raw ASINs; one of `US`, `UK`, `DE`, `CA`, `FR`, `IT`, `ES`.
- `asins`: up to 100 ten-character alphanumeric ASINs.
- `productUrls`: up to 100 HTTPS product URLs on supported Amazon domains.
- Combined inputs: 1 to 100.
- `includeNotFound`: writes or suppresses `NOT_FOUND` dataset records; defaults to `true`.
- `maxConcurrency`: retained as the client concurrency preference; HTTP uses safe tiers of 2, 4, or 6 by batch size.
- `maxBrowserFallbacks`: hard browser cap from 0 to 20; defaults to 3 and is also limited to 20% of valid unique products.
- `proxyConfiguration`: official Apify proxy configuration. **Always residential**: with `useApifyProxy: true` the Actor routes through the RESIDENTIAL proxy group pinned to the marketplace country — there is no datacenter mode. Custom `proxyUrls` (with `useApifyProxy: false`) are the only alternative. See "Proxy and cost" below.
- `debug`: permits PNG evidence for an open browser page only when the memory safety check passes.

ASINs are uppercased, URL tracking is removed, and requests are deduplicated by marketplace + ASIN. A URL's domain overrides the global marketplace. Invalid entries in a mixed list become controlled records without stopping valid items.

### Output

Every dataset record has the same complete set of keys. Missing scalar values are `null`, lists are `[]`, and maps are `{}`.

| Field | Description |
|---|---|
| `status` / `statusMessage` | Per-item outcome: `FOUND`, `PARTIAL`, `NOT_FOUND`, `INVALID_INPUT`, `BLOCKED`, or `FAILED`, with detail. |
| `inputIndex` / `inputType` / `inputValue` | Correlation back to your input (`ASIN` or `URL`). |
| `extractionMethod` | `HTTP`, `BROWSER`, or `NONE`. |
| `marketplace` / `domain` | Marketplace code and Amazon domain. |
| `asin` / `canonicalUrl` | Normalized ASIN and clean `/dp/` product URL. |
| `title` / `brand` / `bylineText` / `bylineUrl` | Product identity. |
| `price` / `priceText` / `listPrice` / `listPriceText` | Current and reference price, numeric and as displayed. |
| `savingsAmount` / `savingsPercent` / `currency` | Discount data and marketplace currency. |
| `availability` / `inStock` / `condition` | Stock status. |
| `primeEligible` / `shipsFrom` / `soldBy` / `sellerName` / `sellerId` / `sellerUrl` | Fulfillment and seller. |
| `rating` / `ratingText` / `reviewCount` / `reviewCountText` / `answeredQuestions` | Demand signals. |
| `bestsellerRanks` | Array of `{rank, category}` Best Sellers ranks. |
| `mainImage` / `images` | Product images. |
| `features` / `description` / `aboutProduct` / `importantInformation` | Product content. |
| `breadcrumbs` / `technicalDetails` | Taxonomy and specifications. |
| `variantAsins` / `variantDimensions` | Product variations (best-effort). |
| `delivery` / `fastestDelivery` / `returnPolicy` | Delivery and returns. |
| `qualityScore` / `missingCoreFields` / `warnings` | Per-record quality (0–100) and diagnostics. |
| `scrapedAt` | ISO timestamp of extraction. |

#### Example output (abridged)

A real `FOUND` record from a US run (long fields shortened, full record has every documented key):

```json
{
  "status": "FOUND",
  "inputType": "ASIN",
  "inputValue": "B0DZ75TN5F",
  "extractionMethod": "HTTP",
  "marketplace": "US",
  "asin": "B0DZ75TN5F",
  "canonicalUrl": "https://www.amazon.com/dp/B0DZ75TN5F",
  "title": "Apple iPad 11-inch: A16 chip, 11-inch Model, Liquid Retina Display, 128GB, Wi-Fi 6, ...",
  "brand": "Apple",
  "price": 426.99,
  "listPrice": 449,
  "savingsPercent": 5,
  "currency": "USD",
  "availability": "In Stock",
  "inStock": true,
  "primeEligible": true,
  "soldBy": "Amazon Resale",
  "rating": 4.7,
  "reviewCount": 26854,
  "mainImage": "https://m.media-amazon.com/images/I/61aPY8odPSL._AC_SX342_SY445_QL70_ML2_.jpg",
  "qualityScore": 97,
  "scrapedAt": "2026-07-29T17:58:35.026Z"
}
```

Core fields (`title`, `price`, `rating`, `mainImage`) are monitored by the run health check: if more than 50% of usable (FOUND/PARTIAL) records come back null on a core field, the run fails naming the dead field. `variantAsins`, `variantDimensions`, `condition`, `answeredQuestions`, and `description` are **best-effort**: Amazon renders them inconsistently (many product pages ship description only as `features`/`aboutProduct`, variants only via scripts), so they may legitimately be `null`/`[]` and never gate a run.

#### Dataset views

- **Overview** — status, method, ASIN, title, price, rating, reviews, brand, seller, quality.
- **Pricing** — price, list price, savings, availability, seller, and fulfillment.
- **Product details** — features, breadcrumbs, technical details, and variations.
- **Problems** — per-item status, missing core fields, and warnings.

The default key-value store also contains:

- `STATS`: run counters, attempts, retries, completeness and quality alerts;
- `ERRORS`: sanitized per-item validation, not-found, block and technical errors.

### Status rules

- `FOUND`: product identified with its essential fields and fewer than two missing commercial fields.
- `PARTIAL`: product identified but at least two of price, availability, rating, review count, brand, or main image are absent.
- `NOT_FOUND`: removed/nonexistent product or incorrect product redirect.
- `INVALID_INPUT`: individual ASIN or URL validation failure.
- `BLOCKED`: CAPTCHA, robot check, unexpected sign-in, or consent wall after the single allowed browser fallback.
- `FAILED`: technical/structural failure or exhausted browser fallback budget.

The run fails in a controlled way if every valid product is blocked/failed or if every supplied entry is invalid.

### Supported marketplaces

| Code | Domain | Currency | Proxy country |
|---|---|---|---|
| US | amazon.com | USD | US |
| UK | amazon.co.uk | GBP | GB |
| DE | amazon.de | EUR | DE |
| CA | amazon.ca | CAD | CA |
| FR | amazon.fr | EUR | FR |
| IT | amazon.it | EUR | IT |
| ES | amazon.es | EUR | ES |

### Quality and privacy

The per-record quality score follows the documented 100-point rubric. Run-level alerts cover empty valid output, failures, missing commercial fields, low average quality, total blocking, and schema validation.

The runtime is HTTP-first. Every valid unique product receives one Cheerio HTTP request. Only blocked, insufficient, connection-failed, or parse-failed HTTP items can enter the proportional Playwright fallback queue. Browser fallback has concurrency 1, no retries, no session rotations, and uses a session separate from HTTP.

No cookie, password, token, proxy URL, credential-bearing URL, or full HTML is written to logs or `ERRORS`. Final error evidence stores gzip-compressed HTML plus JSON. PNG is disabled unless debug is explicitly enabled and memory is below the safety threshold.

### Proxy

All Amazon traffic goes through **Apify RESIDENTIAL proxy** pinned to the marketplace country (`useApifyProxy: true` always routes through the RESIDENTIAL group — there is no datacenter mode). Custom `proxyUrls` (with `useApifyProxy: false`) are the only alternative.

### Pricing

This Actor uses Pay Per Event pricing: **$0.007 per product result — $7 per 1,000 products** — plus a small per-run start fee. You pay for the product records you receive, not for time, retries, or attempts. Check the Pricing tab on this page for the current rates.

Cost-control levers:

- Batch inputs: up to 100 ASINs/URLs per run — one run start fee covers the whole batch.
- `maxBrowserFallbacks` caps the browser-fallback budget (also limited to 20% of valid unique products).
- `includeNotFound: false` suppresses `NOT_FOUND` records from the dataset.

### FAQ

**Do I need an Amazon account or API key?** No. The Actor reads public product pages without logging in.

**Does it collect reviews?** No. It never visits `/product-reviews/` and does not return individual reviews. Use it for product data: price, availability, rating summary, images, specs, and variations.

**Why is a field `null`?** Amazon does not render every field on every product page. Missing values are returned as `null`, never guessed. `variantAsins`, `variantDimensions`, `condition`, `answeredQuestions`, and `description` are best-effort by nature.

**What happens with a dead or wrong ASIN?** It becomes a controlled `NOT_FOUND` or `INVALID_INPUT` record (suppressible via `includeNotFound: false`) — valid items in the same batch are unaffected.

**Can I schedule it?** Yes. Use Apify Schedules with a saved input for recurring price/availability monitoring.

**Is this affiliated with Amazon?** No. This is an unofficial community Actor, not affiliated with or endorsed by Amazon. It collects only public data that any visitor can see.

# Actor input Schema

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

Marketplace used for raw ASINs. Product URLs infer their marketplace from the domain.

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

One ASIN per line. Enter one ASIN per line. Commas, semicolons, spaces, and line breaks are also accepted. Each ASIN must contain exactly 10 alphanumeric characters.

## `productUrls` (type: `array`):

HTTPS Amazon product URLs from one of the seven supported marketplaces.

## `includeNotFound` (type: `boolean`):

Write explicit NOT\_FOUND records to the dataset.

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

Client concurrency preference. The HTTP-first runtime also applies safe batch-size tiers; browser fallback always uses concurrency 1.

## `maxBrowserFallbacks` (type: `integer`):

Maximum number of products allowed to use the browser after HTTP extraction fails. This protects run cost.

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

Official Apify proxy configuration. IMPORTANT: with useApifyProxy=true this Actor always routes through RESIDENTIAL proxy in the marketplace country (there is no datacenter mode); residential transfer is the dominant run cost (~76% observed). Custom proxyUrls require useApifyProxy=false.

## `debug` (type: `boolean`):

Allow PNG evidence while the page is open and memory is below the safety threshold. Error HTML remains gzip-compressed.

## Actor input object example

```json
{
  "marketplace": "US",
  "asins": [
    "B0DCH8VDXF",
    "B0DGHMNQ5Z",
    "B0DZ254SSR"
  ],
  "productUrls": [],
  "includeNotFound": true,
  "maxConcurrency": 2,
  "maxBrowserFallbacks": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

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

Ordered product detail and status records.

## `stats` (type: `string`):

Counters, quality metrics, caps, and warnings.

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

Per-item validation, not-found, blocking, and technical error records.

# 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": [
        "B0DCH8VDXF",
        "B0DGHMNQ5Z",
        "B0DZ254SSR"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/amazon-asin-product-details-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 = {
    "asins": [
        "B0DCH8VDXF",
        "B0DGHMNQ5Z",
        "B0DZ254SSR",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/amazon-asin-product-details-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 '{
  "asins": [
    "B0DCH8VDXF",
    "B0DGHMNQ5Z",
    "B0DZ254SSR"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call johnatan029/amazon-asin-product-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnatan029/amazon-asin-product-details-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/PxeEE2peZhWWY6Vvd/builds/jVB6Lw0VjsQYMIDYx/openapi.json