# Amazon Product Scraper — GPSR, Variants, Offers & A+ Content (`cyprusapi/amazon-product`) Actor

Typed Amazon product data with GPSR/EU compliance, full variant data, offers/buybox, A+ content and provenance — 18 marketplaces, pay per result, errors never charged.

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

## Pricing

from $4.00 / 1,000 product scrapeds

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

### What does Amazon Product Scraper do?

Amazon Product Scraper extracts **full, typed product data** from [Amazon](https://www.amazon.com) across **18 marketplaces** — by ASIN, product URL, or **keyword search** — including pricing, ratings, Best Sellers Rank, buy box, variations, **frequently-bought-together bundles**, **Subscribe & Save pricing**, A+ content, and **free monthly sales and revenue estimates** for niche research. It is the only Amazon product scraper that also delivers **EU GPSR compliance data** (manufacturer, EU responsible person, safety warnings) and an **audit-proof provenance block** (URL, HTTP status, SHA-256 of the page) on every single item — at no extra charge. Whether you need **price intelligence**, **GPSR compliance monitoring for EU sellers**, or **keyword-based niche research with sales estimates**, you get clean, analysis-ready JSON with **per-field coverage status** that never invents a value.

The actor runs on the Apify platform, so you get **API access, scheduling, integrations, proxy rotation, and run monitoring** out of the box — no infrastructure to manage. Pricing is **pay per product** with **no platform-usage passthrough**, and **errors are never charged**. Try it on the Apify free tier in a couple of clicks.

### What makes this Amazon scraper different?

Most Amazon scrapers stop at title, price, and BSR. This one was built for data you can defend — in an audit, in a compliance report, or in a pricing model.

| Capability | Amazon Product Scraper | Typical Amazon scraper |
|---|---|---|
| **GPSR / EU compliance data** (manufacturer, EU responsible person, safety warnings) | ✅ included free | ❌ not available |
| **Provenance / capture block** (URL, HTTP status, SHA-256 page hash) | ✅ on every item | ❌ not available |
| **Per-field coverage status** (`obtained` / `absent` / `unknown`) | ✅ on every item | ❌ silent nulls |
| **Marketplaces** | **18** | 1–3 |
| **Variant price matrix** (every variation child with typed price) | ✅ opt-in add-on | ⚠️ partial or missing |
| **Seller profiles with legal imprint** | ✅ opt-in add-on | ❌ not available |
| **A+ content structure** (premium flags, brand story) | ✅ included | ❌ not available |
| **Sales & revenue estimates** | ✅ model-based, included free | ❌ not available |
| **Keyword search mode** with auto-pagination | ✅ built in | ⚠️ rare |
| **Pricing** | Pay per product ($0.004), **no platform-usage passthrough**, errors never charged | Often per-result **plus** compute/usage fees |

#### GPSR compliance monitoring for EU sellers

Since the EU General Product Safety Regulation (GPSR) took full effect in December 2024, Amazon requires manufacturer and EU responsible-person information on EU listings — and has been deactivating non-compliant listings since 2025, reportedly within 24 hours of detection. For EU sellers and the agencies managing their catalogs, GPSR data is no longer a one-off check but a recurring monitoring task.

This actor extracts the GPSR block **live from the product page's compliance panel** on EU marketplaces:

- **Manufacturer** — name and postal address as displayed
- **EU responsible person(s)** — name and postal address as displayed
- **Product safety images and warnings** — the safety pictograms and documents Amazon renders in the compliance panel

In a live benchmark of 10 ASINs on Amazon.de (August 2026), the actor delivered GPSR data for 9 of 10 products — on the tenth, Amazon verifiably does not render the compliance panel — while two major competing product-data actors returned no GPSR fields at all. GPSR fields are part of the standard `product` event: **no add-on, no extra charge**. Combined with the per-field coverage status and the provenance capture block (URL, HTTP status, SHA-256 of the page), every run doubles as audit-proof evidence of what a listing showed at a point in time — schedule it daily or weekly to watch your whole catalog, or your competitors'.

### How much does it cost to scrape Amazon products?

The actor uses **pay-per-event** pricing — you pay only for delivered results, and there is **no platform-usage passthrough**: unlike some competing Amazon scrapers, we do not bill you for compute units or proxy traffic on top. The event prices below are the whole cost (exact prices are always shown on the actor's **Pricing** tab in Apify Console):

- **`product`** — **$0.004 per product**, charged once per successfully scraped product item. Includes GPSR data, provenance, FBT bundles, Subscribe & Save, A+ content, and sales estimates.
- **`offers`** (opt-in) — **$0.0025 per ASIN**, charged only when the offer list was requested **and actually delivered**. If it can't be delivered, the reason is recorded in `offers_error` and there is no charge.
- **`variant-prices`** (opt-in) — **$0.0015 per ASIN**, charged only when the **complete** variant price matrix was delivered. A partial matrix is attached with `variant_prices_incomplete` but never charged, as are ASINs without variations.
- **`seller-details`** (opt-in) — **$0.0025 per ASIN**, charged only when at least one seller profile was delivered. Undelivered profiles are reported in `seller_details_partial` / `seller_details_error`.
- **`apify-actor-start`** — a one-time **$0.01 per run**.

**Errors are never charged.** Invalid inputs, not-found pages, blocked requests, and transport failures produce transparency items in the dataset at zero cost.

#### Cost by volume (product event only, + $0.01 per run)

| Products per run | Base price | With all three add-ons\* |
|---|---|---|
| 100 products | **$0.41** | $1.06 |
| 1,000 products | **$4.01** | $10.51 |
| 10,000 products | **$40.01** | $105.01 |
| 100,000 products | **$400.01** | $1,050.01 |

\* All add-ons enabled and delivered on every product ($0.004 + $0.0025 + $0.0015 + $0.0025 = $0.0105 per ASIN). Add-ons are charged per ASIN only when delivered, so real-world cost with add-ons is typically lower. The Apify **free tier** is enough to try the actor on a handful of ASINs before you scale up.

### Who is this Amazon scraper for?

| Audience | What they use it for |
|---|---|
| **EU compliance officers & agencies** | Recurring **GPSR monitoring** of client catalogs — manufacturer, EU responsible person, safety warnings — with SHA-256 provenance as audit evidence. |
| **FBA sellers & product researchers** | **Keyword search mode + sales/revenue estimates** for niche research: rank search results, spot sponsored placements, shortlist candidate ASINs, then deep-scrape them. |
| **Brand teams** | Listing and content QA at scale: A+ content structure, brand story, bullets, images, and "Customers say" aspects with verbatim Amazon sentiment counters. |
| **Pricing analysts** | Locale-correct typed prices, list price, discount, price per unit, buy box, full offer lists, and the complete **variant price matrix** across 18 marketplaces. |
| **AI / ML teams** | Clean, typed, provenance-stamped product JSON for training data, retrieval pipelines, and agents — with honest `null` / `"unknown"` semantics instead of hallucinated gaps. |

### How to scrape Amazon product data with Amazon Product Scraper

1. Open the actor in [Apify Store](https://apify.com/store) and click **Try for free**.
2. On the **Input** tab, provide **ASINs** (e.g. `B079VP6DH5`) and/or **Amazon product URLs** (`/dp/...` or `/gp/product/...`) — or switch to **keyword mode** with `keywords` like `["garlic press", "bamboo organizer"]`.
3. Pick the **Marketplace** — domain, locale, currency, and price parsing all follow this setting.
4. Optionally enable **Include offers** for the offer list, **Include variant prices** for the full variant price matrix, **Include seller details** for seller profiles, and **Expand variants** to scrape every variant child with full data.
5. Click **Start**, then download your results from the **Output** or **Storage** tab — or pull them via the Apify API.

#### Using the Apify API (JavaScript)

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('CyprusAPI/amazon-product').call({
    keywords: ['garlic press'],
    maxResultsPerKeyword: 50,
    marketplace: 'com',
    includeOffers: true,
});

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

#### Using the Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_APIFY_TOKEN>')

run = client.actor('CyprusAPI/amazon-product').call(run_input={
    'keywords': ['garlic press'],
    'maxResultsPerKeyword': 50,
    'marketplace': 'com',
    'includeOffers': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Input

The actor accepts the following parameters (see the **Input** tab for the full form). At least one of `asins`, `startUrls`, or `keywords` is required — keyword mode searches the run's marketplace and scrapes the found ASINs as full product items, charged as normal `product` events.

| Field | Type | Description |
|---|---|---|
| `asins` | array | Amazon ASINs (10 characters) to scrape. One dataset item per ASIN. |
| `startUrls` | array | Amazon product URLs; the ASIN is extracted from each URL. Provide `asins` and/or `startUrls`. |
| `keywords` | array | **Keyword mode:** search terms to run on the marketplace's search. Each found ASIN is scraped as a full item and tagged with `search_keyword`, `search_position`, and `sponsored`. |
| `maxResultsPerKeyword` | integer | Cap on unique ASINs scraped per keyword, with auto-pagination. Default `50`, min `1`, max `500`. |
| `marketplace` | string | One of 18 marketplaces: `com`, `de`, `co.uk`, `fr`, `it`, `es`, `ca`, `com.au`, `co.jp`, `in`, `nl`, `se`, `pl`, `be`, `mx`, `br`, `ae`, `sa`. Default `com`. |
| `includeOffers` | boolean | Also fetch the full offer list per ASIN. Charged as a separate `offers` event, only when delivered. Default `false`. |
| `includeVariantPrices` | boolean | Also resolve the full variant price matrix per ASIN (`variant_prices`). Charged as a separate `variant-prices` event, only when the complete matrix was delivered. Default `false`. |
| `includeSellerDetails` | boolean | Also fetch seller profiles (`seller_details`) for every offer seller per ASIN — feedback ratings per period, positive feedback, legal imprint. Charged as a separate `seller-details` event. Default `false`. |
| `expandVariants` | boolean | Enqueue every child ASIN of a variation parent as its own full product item. Default `false`. |
| `maxItems` | integer | Global upper bound of product items per run, across all keywords and other inputs, including expanded variant children. Default `10`. |
| `language` | string | Optional Amazon language code (e.g. `en_US`, `de_DE`) appended to every fetched page. |
| `proxyConfiguration` | object | Proxy settings. Residential proxies are strongly recommended and preselected. |
| `proxiesByMarketplace` | object | Optional geo-pinned custom proxies per marketplace — tried first, ahead of the Apify proxy tiers. |

### Output

One dataset item per scraped product. Flat overview fields (title, price, rating, BSR, availability, image) sit next to full nested groups: `identity`, `core`, `pricing`, `buybox`, `ratings`, `rank`, `demand`, `content`, `variations`, `customer_aspects`, `attributes`, `compliance`, plus `coverage` and `capture`. Items found via keyword mode carry top-level `search_keyword`, `search_position` (1-indexed within that keyword's results, across pages), and `sponsored` (`null` for items from `asins`/`startUrls` or variant expansion). Every item's `demand` group includes the free estimates `bought_in_past_month`, `estimated_monthly_sales`, `estimated_monthly_revenue`, and `estimate_method`. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "asin": "B079VP6DH5",
  "url": "https://www.amazon.com/dp/B079VP6DH5",
  "marketplace": "com",
  "title": "Bounty Paper Towels Quick Size, White, 16 Family Rolls = 40 Regular Rolls",
  "brand": "Bounty",
  "price_current": 43.49,
  "price_list": null,
  "discount_percent": null,
  "currency": "USD",
  "rating_value": 4.8,
  "rating_count": 102341,
  "bsr": 12,
  "availability": "In Stock",
  "in_stock": true,
  "image": "https://m.media-amazon.com/images/I/714Rq4k05UL._AC_SL1000_.jpg",
  "search_keyword": "paper towels",
  "search_position": 7,
  "sponsored": false,
  "demand": {
    "bought_in_past_month": "10K+",
    "estimated_monthly_sales": 10000,
    "estimated_monthly_revenue": "$434,900",
    "estimate_method": "amazon_badge"
  },
  "content": {
    "bullets": ["16 Family Rolls = 40 Regular Rolls ...", "..."],
    "aplus": { "present": true, "is_premium": false, "module_types": ["standard-image", "..."], "brand_story_present": true }
  },
  "variations": {
    "parent_asin": "B07XYZ1234",
    "dimensions": ["Size"],
    "children": [{ "asin": "B079VP6DH5", "dimension_values": { "Size": "16 Family Rolls" } }],
    "child_count": 4
  },
  "frequentlyBoughtTogether": {
    "items": [{ "asin": "B0CB97R25C", "position": 1, "is_current_product": true, "price": 12.99, "price_string": "$12.99" }],
    "item_count": 3,
    "total_price": 38.84,
    "total_price_string": "$38.84",
    "currency": "USD"
  },
  "subscribeAndSave": {
    "price": 8.07,
    "price_string": "$8.07",
    "currency": "USD",
    "tiered_price": 7.22,
    "tiered_price_string": "$7.22 with 28 percent savings",
    "tiered_savings_percent": 28
  },
  "coverage": { "pricing": "obtained", "compliance": "absent", "customer_aspects": "obtained" },
  "capture": {
    "captured_at_utc": "2026-01-15T09:30:00+00:00",
    "url": "https://www.amazon.com/dp/B079VP6DH5",
    "http_status": 200,
    "was_authenticated": false,
    "content_hash": "sha256:1a2b3c..."
  },
  "scrapedAt": "2026-01-15T09:30:05+00:00"
}
```

The `demand` estimates work like this: `bought_in_past_month` is Amazon's badge text verbatim (e.g. `"10K+"`); when a badge exists, `estimated_monthly_sales` is its bucket floor (`"10K+"` → `10000`) with `estimate_method: "amazon_badge"`; otherwise a BSR-model heuristic is used with `estimate_method: "bsr_model"`. `estimated_monthly_revenue` is monthly sales × current price as a formatted string in the product's currency with marketplace separators (e.g. `"$434,900"`, `"3.745 €"`). All four fields are `null` when no estimate is possible.

On EU marketplaces the `compliance` block additionally carries **GPSR data** (manufacturer, EU responsible person, safety warnings) extracted live from the product page. The `frequentlyBoughtTogether` and `subscribeAndSave` blocks are part of the standard `product` event (no add-on charge); they are currently verified live on amazon.com and amazon.de, using language-stable selectors across the other marketplaces.

Fields follow a **three-state discipline**: a value means *observed*, `null` means *verifiably absent*, and `"unknown"` means *not observable anonymously* — the `coverage` block reports this per field group. Failed ASINs appear as transparency items with `error` and `errorDescription` and are never charged.

### Data table

| Field | Description |
|---|---|
| `asin`, `url`, `marketplace` | Product identity and canonical URL |
| `title`, `brand` | Product title and brand (plus byline, brand store, breadcrumb in `core`) |
| `price_current`, `price_list`, `discount_percent`, `price_per_unit`, `currency` | Typed numeric prices, locale-aware parsing |
| `rating_value`, `rating_count` | Star rating and review count, with scope (marketplace/worldwide) and histogram in `ratings` |
| `bsr` | Best Sellers Rank (all nodes and badges in `rank`) |
| `demand` | Free estimates: `bought_in_past_month` (verbatim badge), `estimated_monthly_sales`, `estimated_monthly_revenue`, `estimate_method` (`amazon_badge` / `bsr_model`) — model-based, see Known limitations |
| `search_keyword`, `search_position`, `sponsored` | Search context for items found via keyword mode (`null` for ASIN/URL/variant-expansion items) |
| `availability`, `in_stock` | Availability message and stock flag |
| `buybox` | Featured offer, seller, offer count, fulfillment |
| `offers` | Full offer list: seller name/ID, price, condition, shipping, delivery, ships from (with `includeOffers`) |
| `variant_prices` | Variant price matrix: every variation child with typed price and dimension values (with `includeVariantPrices`) |
| `seller_details` | Seller profiles of the offer sellers: ratings per period, positive feedback, legal imprint (with `includeSellerDetails`) |
| `variations` | Parent ASIN, dimensions, all children with dimension values |
| `frequentlyBoughtTogether` | "Frequently bought together" bundle: component ASINs with typed prices, bundle total, currency — `null` when Amazon doesn't render the module |
| `subscribeAndSave` | Subscribe & Save price and tiered-unlock price (verbatim from Amazon's tiered label, e.g. "$7.22 with 28 percent savings") — `null` when not offered |
| `content` | Bullets, description, images, video, A+ structure with premium flags and brand story |
| `customer_aspects` | "Customers say" aspects with verbatim Amazon sentiment counters |
| `attributes` | Merged specifications from overview, product-information tables, and detail bullets |
| `compliance` | GPSR block, legal notices (warranty, seller), product documents (PDFs) |
| `coverage` | Per-field-group status: `obtained` / `absent` / `unknown` |
| `capture` | Provenance: timestamp, URL, HTTP status, user agent, SHA-256 content hash |

### Known limitations

We'd rather you know these up front:

- **Sales and revenue estimates are model-based heuristics, not measured sales.** When Amazon shows a "bought in past month" badge, the estimate is the badge's bucket floor (`estimate_method: "amazon_badge"`); otherwise a BSR-curve fallback is used (`estimate_method: "bsr_model"`). Treat `estimated_monthly_sales` and `estimated_monthly_revenue` as an **order-of-magnitude ranking signal** for comparing products — not as validated accuracy figures. We deliberately publish no error percentages, because we don't have ground-truth sales data to validate against.
- **No review text.** This actor extracts product-page data (including rating histograms and "Customers say" aspects), not individual customer reviews. For review text, use our sibling [Amazon Reviews Scraper](https://apify.com/store), which goes beyond Amazon's 100-review display limit.
- **Browser-based rendering is slower than pure-HTTP scrapers.** The actor renders pages in a real browser, which costs some speed but reliably handles Amazon's bot-wall layouts and JS-rendered modules (GPSR panel, A+ content, FBT) that plain HTTP scrapers often miss.
- **Variant pricing is an opt-in add-on.** The full variant price matrix requires `includeVariantPrices` (separate `variant-prices` event) because resolving every child's price takes extra requests; ASINs without variations are never charged for it.
- **One marketplace per run.** All ASINs in a run are fetched from the same marketplace; split multi-marketplace jobs into separate runs.

### Tips and advanced options

- **Use `maxItems`** to cap run size and cost — it's the global cap across all keywords and inputs, and matters especially with `expandVariants`, where a single parent can enqueue dozens of children (deduplicated and capped).
- **Proxy fallback chain.** Each ASIN is attempted in tiers: your own `proxiesByMarketplace` pool first, then Apify datacenter proxies, then Apify residential. Retries only happen on bot-detection/transport failures (`not_found` is final). If your `proxyConfiguration` already uses residential groups, the datacenter hop is skipped — and Apify residential availability (incl. on the free plan) depends on your account plan.
- **Match proxies to the marketplace.** Residential proxies are preselected; with `proxiesByMarketplace` you can pin geo-located exit IPs per marketplace. A mismatched exit IP makes Amazon serve wrong currencies or bot-gates.
- **Force a language** with `language` (e.g. `en_US`) if you need consistent copy across locales — by default the marketplace's native language is used.
- **Automate it.** Schedule recurring runs, chain the actor in Apify integrations, or call it from your stack via the Apify API.

### FAQ

#### Will Amazon block me? Do I need proxies?

Amazon actively rate-limits and bot-gates scraping traffic, which is why **residential proxies are preselected** and each ASIN is retried through a tiered fallback chain (your proxies → datacenter → residential) on bot-detection. Blocked requests surface as transparency items with `error` / `errorDescription` and are **never charged**.

#### Can I bring my own proxies?

Yes. Add your own endpoints via `proxyConfiguration.proxyUrls`, or pin **geo-located proxies per marketplace** with `proxiesByMarketplace` (e.g. German exits for amazon.de) — your pool is always tried first.

#### How fresh is the Best Sellers Rank?

BSR is scraped **live at run time** from the product page — it's exactly the rank Amazon displayed at the capture moment recorded in `capture.captured_at_utc`. Amazon refreshes BSR roughly hourly, so scheduled runs give you a true time series.

#### How accurate are the sales and revenue estimates?

Honestly: they're a **model-based ranking signal**, not measured sales. Badge-floor-derived when Amazon shows "bought in past month", BSR-model-based otherwise — the `estimate_method` field (`amazon_badge` vs `bsr_model`) tells you which signal each value rests on. Use them to rank and compare products within a niche, not as precise revenue figures — see Known limitations above.

#### Is scraping Amazon product data legal?

Web scraping is legal when you extract **publicly available data** that is not behind a login. This actor scrapes only anonymous, public product pages (`was_authenticated` is always `false` in the provenance block). Note that personal data is protected by regulations such as GDPR in the EU — you should have a legitimate reason to scrape personal data. If you are unsure, consult a lawyer. Also review Amazon's Terms of Service before scraping. Apify is not liable for how you use the extracted data.

#### Why did some fields come back as `null` or `"unknown"`?

That is the honest-data design, not a bug: `null` means the field is verifiably absent on the page, `"unknown"` means it could not be observed anonymously. The `coverage` block tells you which case applies per field group — no invented values.

#### Something isn't working — where do I report it?

Open the **Issues** tab on the actor's page in Apify Console and describe the problem, ideally with the failing ASIN, marketplace, and run ID. Error items in the dataset (`error` / `errorDescription`) already tell you what went wrong for individual ASINs.

#### Can you build a custom Amazon data solution?

Yes — if you need different fields, additional marketplaces, or a fully managed pipeline, reach out via the Issues tab and ask about a custom solution.

# Actor input Schema

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

Amazon ASINs (10 characters) to scrape, e.g. B079VP6DH5. One dataset item per ASIN. Provide asins, startUrls and/or keywords.

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

Amazon product URLs (/dp/... or /gp/product/...). The ASIN is extracted from each URL; the run's marketplace setting decides which Amazon domain is fetched. Provide asins, startUrls and/or keywords.

## `keywords` (type: `array`):

Optional: search the marketplace for these keywords and scrape the found products as full product items (charged as the normal 'product' event). Result pages are paginated until maxResultsPerKeyword unique ASINs per keyword are collected or results run out; each item carries search\_keyword, search\_position and sponsored. Provide asins, startUrls and/or keywords.

## `maxResultsPerKeyword` (type: `integer`):

Upper bound of unique ASINs collected per keyword. maxItems remains the global cap across all keywords and inputs.

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

Amazon marketplace all ASINs are fetched from (domain, locale, currency, and price-parsing logic follow this setting).

## `includeOffers` (type: `boolean`):

Also fetch the full offer list per ASIN (All Offers Display, falling back to /gp/offer-listing): seller name/id, price, condition, shipping, delivery, ships\_from. The list is stored inside the product item as offers: \[...] and charged as a separate 'offers' event per ASIN; failures are noted as offers\_error and are free.

## `includeVariantPrices` (type: `boolean`):

Also resolve the full variant price matrix per ASIN (every child of a variation parent with its typed price, via Amazon's twister endpoint): stored as variant\_prices: \[...] and charged as a separate 'variant-prices' event per ASIN — only when the COMPLETE matrix was delivered. Partial matrices (variant\_prices\_incomplete) and ASINs without variations are free.

## `includeSellerDetails` (type: `boolean`):

Also fetch the seller profile (/sp page) of every offer seller per ASIN: ratings per period (30d/90d/365d/lifetime), positive feedback percent and the legal imprint (business name, address, VAT id) — stored as seller\_details: \[...] and charged as a separate 'seller-details' event per ASIN with at least one delivered profile. Requires the offer list; it is fetched automatically (charged as 'offers' only when Include offers is also on).

## `expandVariants` (type: `boolean`):

When a parsed product is a variation parent, enqueue every child ASIN as its own full product task (deduplicated, capped by maxItems). Each child becomes its own charged product item.

## `maxItems` (type: `integer`):

Upper bound of product items pushed in this run (including expanded variant children).

## `language` (type: `string`):

Optional Amazon language code (e.g. en\_US, de\_DE) appended as ?language= to every fetched page. By default the marketplace's verified language cookie is used.

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

Residential proxies are strongly recommended. Custom proxies can be added as proxyUrls (http://user:pass@host:port).

## `proxiesByMarketplace` (type: `object`):

Optional: {"de": \["http://user:pass@host:port", …], "co.uk": \[…]}. Geo-pinned proxies per marketplace — exit-IP country should match the marketplace, otherwise Amazon serves wrong currencies or bot-gates. Proxy tier chain per task: this explicit pool FIRST; otherwise the bundled shared pool (we cover it); on blocked/transport the run falls back to Apify datacenter, then Apify residential. With useApifyProxy off and no pool at all: single direct attempt.

## Actor input object example

```json
{
  "asins": [
    "B079VP6DH5"
  ],
  "startUrls": [
    "https://www.amazon.com/dp/B079VP6DH5"
  ],
  "maxResultsPerKeyword": 50,
  "marketplace": "com",
  "includeOffers": false,
  "includeVariantPrices": false,
  "includeSellerDetails": false,
  "expandVariants": false,
  "maxItems": 10,
  "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": [
        "B079VP6DH5"
    ],
    "startUrls": [
        "https://www.amazon.com/dp/B079VP6DH5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cyprusapi/amazon-product").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": ["B079VP6DH5"],
    "startUrls": ["https://www.amazon.com/dp/B079VP6DH5"],
}

# Run the Actor and wait for it to finish
run = client.actor("cyprusapi/amazon-product").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": [
    "B079VP6DH5"
  ],
  "startUrls": [
    "https://www.amazon.com/dp/B079VP6DH5"
  ]
}' |
apify call cyprusapi/amazon-product --silent --output-dataset

```

## MCP server setup

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

```

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/uWM5Wi8M0dSC7TaFL/builds/tLRDIENu44bffm83V/openapi.json