# Amazon Product Details — Independent (`peerless_columbine/independent-amazon-products`) Actor

Collect public Amazon product details, observed prices and stock evidence. Direct product URLs are cloud-validated; search and variant options have bounded local evidence only. Independent tool.

- **URL**: https://apify.com/peerless\_columbine/independent-amazon-products.md
- **Developed by:** [tingyou333 zhuang](https://apify.com/peerless_columbine) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 product rows

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Product Details — Independent

Extract publicly visible Amazon product information into structured records: ASIN, title, displayed price, stock text, images, specifications and linked variants. Use small snapshots for catalog research, price comparisons and availability checks. This is an independent tool, not affiliated with or endorsed by Amazon.

**Coverage:** direct product collection has passed a one-product cloud check. Search pagination and variant collection have bounded local evidence; complete search coverage, every variant, every country and delivery-location overrides are not guaranteed. Prices and availability reflect the anonymous page at collection time.

### Quick start

1. Add a public Amazon product URL to `categoryOrProductUrls`.
2. Start with one result and proxy use disabled. The input below is the actual input used for the verified cloud sample.
3. Download the product dataset as JSON, CSV or Excel. Check the `SUMMARY` record for missing fields, blocked pages and collection limits.

```json
{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/dp/B0G8M2FH2G"
    }
  ],
  "maxItemsPerStartUrl": 1,
  "maxSearchPagesPerStartUrl": 1,
  "maxProductVariantsAsSeparateResults": 0,
  "maxOffers": 0,
  "scrapeSellers": false,
  "maxRequests": 3,
  "maxConcurrency": 1,
  "requestTimeoutSecs": 20,
  "maxRetries": 1,
  "maxRunSeconds": 90,
  "useProxy": false,
  "dnsMode": "system"
}
```

For search, use a normal Amazon `/s` URL such as `https://www.amazon.com/s?k=keyboard`, set `maxSearchPagesPerStartUrl` to a small number, and choose whether to fetch detailed product pages with `scrapeProductDetails`. Search-card mode (`false`) is lighter and leaves detail-only fields, including stock, unknown.

For variants, set `maxProductVariantsAsSeparateResults` above zero to emit linked sibling products. `scrapeProductVariantPrices=true` requests sibling detail pages for prices. These options use additional requests and can stop before the complete family is fetched.

### Inputs

| Input | Default | Behavior |
|---|---|---|
| `categoryOrProductUrls` | Required | Public product or `/s` search/category URLs, as strings or `{ "url": "..." }` objects. URL filters and sort order are retained. |
| `maxItemsPerStartUrl` | `100` | Maximum persisted rows per starting URL, including separate variants. `0` returns no rows. |
| `maxSearchPagesPerStartUrl` | `9999` | Maximum search pages; request, row and time budgets normally stop a small run sooner. |
| `scrapeProductDetails` | `true` | Visit each found product for details; `false` emits source search cards with unavailable detail fields null. |
| `maxProductVariantsAsSeparateResults` | `0` | Maximum sibling variants emitted as separate rows. |
| `scrapeProductVariantPrices` | `false` | Fetch sibling prices; missing prices stay null. |
| `maxVariantRequestsPerProduct` | `20` | Cap on variant-page requests per product. Partial coverage is reported. |
| `language` | Site default | Request a mapped locale; unsupported market/language combinations fall back with a warning. |
| `maxRequests` | `40` | Maximum HTTP attempts, including redirects and retries. |
| `maxConcurrency` | `2` | Concurrent requests, supported range `1–4`; larger values fail validation. |
| `requestTimeoutSecs` / `maxRetries` | `15` / `1` | Bounded attempt timeout and transient retries. Challenges and HTTP 403/404 are not retried. |
| `maxRunSeconds` | `105` | Collection deadline, maximum 105 seconds. |
| `useProxy` / `proxyConfiguration` | `false` / disabled | Optional user-owned Apify or HTTP proxy. Default collection needs no proxy. Real paid-proxy behavior has not been accepted in live testing. |
| `proxyCountry` | `AUTO_SELECT_PROXY_COUNTRY` | Applies when using your Apify proxy; it does not control a direct request's geography. |
| `dnsMode` | `system` | Optional `google-doh` mode for synthetic local DNS; public-IP and TLS checks remain enabled. |
| `maxTotalChargeUsd` | No extra input cap | Additional output-event fee cap if result billing is active. It does not cap platform compute/storage/network costs. |

The exposed optional enrichment inputs `maxOffers` and `scrapeSellers` have limited public-page parsers but **no successful complete live acceptance**. Leave them at `0` and `false` for the advertised product-detail workflow. Missing offer/seller layouts appear in `SUMMARY`.

Delivery overrides `countryCode` and `zipCode` are unsupported and fail explicitly. `locationDeliverableRoutes` cannot enable them. `useCaptchaSolver=true` is rejected. Shortened URLs, request-list files, bestsellers entry workflows and non-GET requests are unsupported. Although `/b` URL syntax is accepted, category-node behavior has not been validated; use documented `/s` category URLs.

### Output

| Field | Type | Meaning |
|---|---|---|
| `asin`, `title`, `url` | String | Product identity and canonical public URL. |
| `price`, `listPrice`, `shippingPrice` | Object or null | `{ "value": number, "currency": string }` using the displayed code or symbol. Missing is not zero. |
| `inStock`, `inStockText` | Boolean/string or null | Explicit page availability. Unknown stock is null, not false. |
| `brand`, `features`, `description` | String/array or null | Visible catalog content when the supported layout provides it. |
| `thumbnailImage`, `galleryThumbnails`, `highResolutionImages` | String/array or null | Images exposed in the product's public gallery. |
| `stars`, `reviewsCount` | Number or null | Visible aggregate rating information; customer review text is not crawled. |
| `variantAsins`, `variantDetails`, `variantAttributes` | Array or null | Publicly linked siblings and selected dimensions. Child prices require enrichment and may remain null. |
| `priceRange` | Object or null | Range of observed child prices. Read `_source.priceRangeCoverage`; an incomplete subset is not the full-family range. |
| `categoryPageData` | Object or null | Source search URL, page number, position and available sponsorship/badge information. |
| `_source` | Object | Fetch time, page type, response hash, displayed currency interpretation, and missing-field/coverage information. |

Additional compatible field names are retained, but presence in the schema is not a completeness promise. Sustainability features, video counts, product comparisons and bestsellers metadata are unimplemented; complex A+/brand-story content is partial. Error records never enter the product dataset: diagnostics and stop reasons belong to `SUMMARY`.

#### Actual output example

This excerpt is from the one-product cloud sample captured on 26 September 2026 (UTC). It is a historical observation, not a current price quote. Copy the input in Quick start and inspect the selected output fields below. The dated sample and its coverage are described in [Latest acceptance sample](#latest-acceptance-sample).

```json
{
  "asin": "B0G8M2FH2G",
  "title": "SANDISK 256B Extreme microSD Card + Adapter, Up to 245MB/s Read Speeds",
  "url": "https://www.amazon.com/dp/B0G8M2FH2G",
  "price": {
    "value": 74.99,
    "currency": "$"
  },
  "inStock": true,
  "inStockText": "In Stock",
  "_source": {
    "currencyCode": null,
    "retrievedAt": "2026-09-26T18:39:34.575695+00:00",
    "httpStatus": 200
  }
}
```

The raw `$` symbol is preserved and `_source.currencyCode` stays null because the specific dollar currency was not established. Amazon.com does **not** imply USD. Other observed pages displayed KRW; no currency conversion or forced relabeling is performed. `_source.marketplaceDefaultCurrency` is geographic context only. The source title is preserved as received, including its spelling.

### Search, variants and availability limits

- Search follows actual Next links, keeping URL-level filters and sort settings. It preserves source order and sponsored results. It stops on row/page/request/time limits, missing Next links and repeated pages/products. It does not invent pages or locally remove results based on guessed relevance.
- Deduplication is global by marketplace host and ASIN, so the same product encountered under multiple starting URLs can appear once.
- Local samples followed two pages with 37 rows/33 displayed prices, and a filtered/sorted search with 32 rows/31 prices. These are bounded observations, not a success-rate or all-filters guarantee.
- A linked variant's price and stock were verified, with price coverage only **1 of 12** discovered variants. Full-family extraction is not claimed.
- Locale, shipping context, currency and source layout can change the offer shown. No all-country or native GBP/EUR/JPY coverage claim is made.
- A random query returned product cards rather than an explicit empty-result message. Genuine empty-result handling has offline tests but no passing live empty-page example.
- The Actor uses anonymous public HTTP pages. It does not log in, read personal cookies, solve CAPTCHAs or include a browser-rendering fallback in its runtime image.

### Pricing

The paid unit is **one valid product row saved in the default dataset**. Each separately saved record is another row. Inline arrays do not create extra row events. Failed requests, duplicate rows and diagnostic records do not create result events. A valid source record may have nullable optional fields; a row charge does not guarantee every field.

| Apify plan | USD per row | USD per 1,000 rows |
|---|---:|---:|
| FREE | 0.004 | 4.00 |
| BRONZE | 0.0034 | 3.40 |
| SILVER | 0.0028 | 2.80 |
| GOLD | 0.0022 | 2.20 |
| PLATINUM | 0.0022 | 2.20 |
| DIAMOND | 0.0022 | 2.20 |

There is no startup event fee. FREE names the Apify subscription tier; it does not mean results are free. The Pricing tab shows the active rate before a run.

**Apify platform compute, storage and transfer are charged separately**, including for failed or empty runs. An explicitly enabled proxy can add provider fees. A row limit is not an all-inclusive dollar cap. Use small inputs first and inspect actual run usage. Historical owner test runs are not customer revenue or cost forecasts.

### API usage

Use the existing Actor ID with an Apify token supplied through your environment. Access and active pricing depend on the Actor's current platform settings.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("SSTtC20zO6CRpgqnf").call(
    run_input={
        "categoryOrProductUrls": [{"url": "https://www.amazon.com/dp/B0G8M2FH2G"}],
        "maxItemsPerStartUrl": 1,
        "maxRequests": 3,
        "maxConcurrency": 1,
        "maxRunSeconds": 90,
        "useProxy": False,
    },
    memory_mbytes=256,
    timeout_secs=120,
)
products = client.dataset(run["defaultDatasetId"]).list_items().items
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")
```

You can use Apify schedules and dataset integrations for repeated snapshots. Review `SUMMARY` and actual costs alongside each dataset; a completed run does not guarantee every requested field or page was available.

### FAQ

**Can I get a price for every product?** No. Anonymous delivery context or an unsupported source layout may hide offers. Missing prices remain null and product rows can still be charged if result billing is active.

**Can I choose a ZIP code or delivery country?** No. Those overrides explicitly fail. An optional proxy country is a network setting and is not a delivery-address substitute.

**Are search and variants supported?** Bounded HTTP collection is implemented and has local examples. The accepted cloud sample covers one direct product; broader cloud search/variant coverage is unverified.

**Does this replace Junglee's full Amazon crawler?** No. Some input/output names are compatible, but optional enrichment, nested shapes, delivery controls and coverage differ. Review [Inputs](#inputs), [Output](#output), and [Search, variants and availability limits](#search-variants-and-availability-limits) before migrating; these sections state the supported fields and material differences.

**Why is a field null or an array incomplete?** The source did not supply supported data, the layout was unsupported, or collection reached a cap. Inspect `_source.missingFields`, variant coverage and `SUMMARY`; nulls and partial arrays are not invented values.

**Why does `SUMMARY.releaseReady` say false?** That legacy field is always false in this version; it is not a live test of dataset availability or a run failure. Check the actual fields, `status`, errors and coverage instead.

**Is this an official Amazon product?** No. The icon uses an official-site identification asset with an independent-tool label; Amazon does not endorse this Actor.

### Latest acceptance sample

The quickstart input was checked in Apify Cloud on 2026-09-26 (UTC; run finished at 2026-09-26T18:39:36.927Z). It saved 1 valid rows. The output example on this page copies real source values from that dataset; it is a dated sample, not current inventory or a current quote.

One direct product, ASIN B0G8M2FH2G, returned a displayed price of 74.99 with the source dollar symbol and explicit In Stock text. The currency code remains unknown. Search and variants have bounded local evidence only.

# Actor input Schema

## `categoryOrProductUrls` (type: `array`):

Public Amazon product or /s search/category URLs. URL filters and sort parameters are retained across Next links; no reviews are crawled.

## `maxItemsPerStartUrl` (type: `integer`):

Total rows per start URL, including separate variants. Zero requests no rows. Our default is 100; competitor publishes a prefill, not a runtime default.

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

Public language query parameter. Supported mapping is documented; unsupported marketplace/language combinations fall back with a summary warning.

## `proxyCountry` (type: `string`):

Apify proxy country when useProxy=true. AUTO requires a single marketplace per run. No proxy is used by default.

## `maxSearchPagesPerStartUrl` (type: `integer`):

Stop after this many search pages, item cap, no Next link or repeated page. A separate request/time budget also applies.

## `maxProductVariantsAsSeparateResults` (type: `integer`):

Fetch up to this many sibling variants as separate rows. Additional request and time caps apply.

## `maxOffers` (type: `integer`):

Parse up to this many offers from the ordinary public offer listing. If no offer layout is returned, SUMMARY records an explicit gap.

## `scrapeSellers` (type: `boolean`):

Fetch public seller profiles and parse supported fields. Unavailable layouts are recorded in SUMMARY.

## `useCaptchaSolver` (type: `boolean`):

Unsupported: true fails input validation. CAPTCHA solving is never executed.

## `scrapeProductVariantPrices` (type: `boolean`):

Fetch variant detail pages for observed prices; missing or capped variants remain null and coverage is disclosed.

## `scrapeProductDetails` (type: `boolean`):

True visits product detail pages. False emits explicitly tagged search-card rows with unavailable detail fields null.

## `countryCode` (type: `string`):

Not implemented: any nonempty override fails validation; no silent ignored delivery settings.

## `zipCode` (type: `string`):

Not implemented: any nonempty override fails validation.

## `locationDeliverableRoutes` (type: `array`):

Validated compatibility field. No overrides are applied because countryCode/zipCode are unsupported.

## `maxRequests` (type: `integer`):

Maximum HTTP attempts including redirects and retries.

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

Concurrent requests. Values 1–4 are honored; higher inputs fail validation for the 256MB profile.

## `requestTimeoutSecs` (type: `integer`):

Timeout per HTTP attempt.

## `maxRetries` (type: `integer`):

Retries only for transient network or HTTP errors; no challenge retries.

## `maxRunSeconds` (type: `integer`):

End-to-end collection deadline; leaves room within the 120 second cloud run.

## `maxVariantRequestsPerProduct` (type: `integer`):

Safety cap for separate variant page requests; partial coverage is explicit.

## `dnsMode` (type: `string`):

Explicit Google DoH mode for local fake-IP DNS; TLS/public-IP validation remains enabled.

## `useProxy` (type: `boolean`):

Opt in to the supplied configuration; can incur your provider costs. Not used in development validation.

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

Apify or custom HTTP proxy. Configuration errors fail explicitly; credential values are never written to evidence.

## `maxTotalChargeUsd` (type: `number`):

Additional event-fee cap if platform billing is ever enabled. Does not cover compute/network charges; free mode still outputs.

## Actor input object example

```json
{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/dp/B0G8M2FH2G"
    }
  ],
  "maxItemsPerStartUrl": 2,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxSearchPagesPerStartUrl": 2,
  "maxProductVariantsAsSeparateResults": 0,
  "maxOffers": 0,
  "scrapeSellers": false,
  "useCaptchaSolver": false,
  "scrapeProductVariantPrices": false,
  "scrapeProductDetails": true,
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "maxRequests": 40,
  "maxConcurrency": 2,
  "requestTimeoutSecs": 15,
  "maxRetries": 1,
  "maxRunSeconds": 105,
  "maxVariantRequestsPerProduct": 20,
  "dnsMode": "system",
  "useProxy": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "categoryOrProductUrls": [
        {
            "url": "https://www.amazon.com/dp/B0G8M2FH2G"
        }
    ],
    "maxItemsPerStartUrl": 2,
    "maxSearchPagesPerStartUrl": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("peerless_columbine/independent-amazon-products").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 = {
    "categoryOrProductUrls": [{ "url": "https://www.amazon.com/dp/B0G8M2FH2G" }],
    "maxItemsPerStartUrl": 2,
    "maxSearchPagesPerStartUrl": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("peerless_columbine/independent-amazon-products").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 '{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/dp/B0G8M2FH2G"
    }
  ],
  "maxItemsPerStartUrl": 2,
  "maxSearchPagesPerStartUrl": 2
}' |
apify call peerless_columbine/independent-amazon-products --silent --output-dataset

```

## MCP server setup

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

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/SSTtC20zO6CRpgqnf/builds/Vr8tFybRxokAw8UNA/openapi.json