# Amazon India Product Details (`ikmal_suzali_atr/amazon-in-details`) Actor

Full Amazon India product details by ASIN or URL (India (amazon.in)): title, brand, buybox price, list price and discount, rating and review count, availability, seller and ships-from, delivery promise for a pincode, category path, bullets, specifications, description, images, variants and Best…

- **URL**: https://apify.com/ikmal\_suzali\_atr/amazon-in-details.md
- **Developed by:** [AtTheRate AI](https://apify.com/ikmal_suzali_atr) (community)
- **Categories:** 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/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 India Product Details

Reads the full amazon.in product page for any ASIN and returns it as one clean row: buybox price, list price and discount, availability, rating and reviews, seller and ships-from, images, bullet points, Best Sellers Rank and variants. Give it a 6-digit pincode and the page is read as a shopper in that area sees it, so the price, the seller and the delivery promise are the local ones.

### What you get

- Pincode-accurate reading: pass `pincode` and the delivery area is set before the page is fetched. Every row records `location_applied` and `delivery_location`.
- Buybox pricing: `price`, `original_price`, `discount_percent` and `currency` (INR).
- Availability as Amazon states it: `in_stock`, the raw `availability` line and `stock_quantity`.
- Who is selling: `seller`, `seller_id` and `ships_from`, plus the `delivery` promise for that pincode.
- Reviews and ranking: `rating`, `rating_count`, `best_sellers_rank`, `bsr_top` and `bsr_top_category`.
- Content: `name`, `brand`, `highlights`, `description`, `specifications`, `images` and `images_count`.

### Input

Pass ASINs or product URLs, and a pincode if you want local pricing and delivery.

```json
{
  "asins": ["B0CHX1W1XY"],
  "locale": "in",
  "pincode": "122002",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
}
```

- `asins` (required): 10-character ASINs or product URLs such as `.../dp/<ASIN>`. Duplicates are ignored and every input gets one row.
- `locale`: `in` for amazon.in, the only storefront this actor covers.
- `pincode`: optional 6-digit Indian pincode. Anything else is rejected before the run starts.
- `maxConcurrency`: products fetched in parallel, 1 to 4. Two is the safe default.
- `proxyConfiguration`: residential proxy in India, already the default.

### Output

One row per requested ASIN or URL. Real row from a 40 ASIN run at pincode 122002.

```json
{
  "platform": "amazon-in",
  "locale": "in",
  "pincode": "122002",
  "requested": "B0HFX8WCNF",
  "found": true,
  "asin": "B0HFX8WCNF",
  "name": "Google Pixel 11 5G (Obsidian)",
  "brand": "Google",
  "price": 82390,
  "original_price": 89999,
  "discount_percent": 8,
  "currency": "INR",
  "rating": 4.5,
  "rating_count": 2,
  "in_stock": true,
  "availability": "In stock",
  "seller": "The Rising Star",
  "ships_from": "Amazon",
  "delivery": "FREE delivery Wednesday, 16 September. Or fastest delivery Tomorrow 8 am - 12 pm.",
  "delivery_location": "Gurugram 122002",
  "location_applied": true,
  "bsr_top": 2197,
  "bsr_top_category": "Electronics",
  "category_path": ["Electronics", "Mobiles & Accessories", "Smartphones"],
  "images_count": 5,
  "product_url": "https://www.amazon.in/dp/B0HFX8WCNF"
}
```

`price` is null when there is no buybox offer, for example on an unavailable product. A dead ASIN returns a row with `found: false` and an `error` rather than failing the run. Repeated ASINs are deduplicated: a 40 ASIN input with 4 duplicates returned 36 rows.

### Use cases

- City-level comparison: run the same ASIN list against several pincodes and compare `price`, `seller` and `delivery`.
- Buybox and seller watch: alert when `seller` or `ships_from` changes on a listing you own.
- Availability monitoring: `in_stock` and `availability` catch out-of-stock windows early.

### Notes and limits

- Price is read only from the buybox block. Carousels such as "customers also bought" are ignored, so an unavailable product returns `price: null` rather than a neighbour's price.
- A residential proxy in India is required. amazon.in challenges datacentre and non-Indian addresses more often than the other storefronts.
- A pincode that is not 6 digits fails input validation before the run starts, so no compute is billed.
- `location_applied` tells you whether Amazon accepted the pincode. If it did not, the run continues with the default location.
- Every input produces a row. Invalid ids, missing products and errors come back as `found: false` with the reason.

### FAQ

**Do I need a proxy?** Yes, residential in India. The actor already defaults to residential IN.

**How does the pincode work?** The actor sets the delivery location on the session before fetching, the same way the location picker on the site does. The page then shows local availability, the local buybox seller and the local delivery date.

**Does it need a login or an API key?** No. Public product pages only, no account and no seller credentials.

**What happens with a wrong or dead ASIN?** You get a row with `found: false` and the reason. The run still succeeds and the other ASINs are unaffected.

# Actor input Schema

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

Amazon ASINs (10 characters, e.g. B0CHX1W1XY) or product URLs (…/dp/<ASIN>, …/gp/product/<ASIN>). Duplicates are ignored; every input gets one output row.

## `locale` (type: `string`):

Which Amazon storefront to read the product from. ASINs are storefront-specific.

## `pincode` (type: `string`):

Optional 6-digit Indian pincode. Sets the delivery location before fetching, so the delivery promise (and, for regional sellers, availability and the buybox seller) reflect that area.

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

How many product pages are fetched at the same time (1–4). Amazon rate-limits per session; 2 is safe.

## `delayMs` (type: `integer`):

Pause between product fetches.

## `callsPerSession` (type: `integer`):

Re-mint the session (fresh cookies and proxy exit) after this many product fetches.

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

On the Apify platform this decides egress; a residential proxy in the storefront's country (IN for the default storefront) is strongly recommended — Amazon serves a captcha to datacenter IPs. On our own servers it is ignored and our residential proxy is used.

## Actor input object example

```json
{
  "asins": [
    "B0CHX1W1XY"
  ],
  "locale": "in",
  "pincode": "122002",
  "maxConcurrency": 2,
  "delayMs": 1000,
  "callsPerSession": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

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

One row per product.

## `summary` (type: `string`):

Counts for the run: what was requested, captured, skipped and failed.

# 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": [
        "B0CHX1W1XY"
    ],
    "pincode": "122002"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ikmal_suzali_atr/amazon-in-details").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": ["B0CHX1W1XY"],
    "pincode": "122002",
}

# Run the Actor and wait for it to finish
run = client.actor("ikmal_suzali_atr/amazon-in-details").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": [
    "B0CHX1W1XY"
  ],
  "pincode": "122002"
}' |
apify call ikmal_suzali_atr/amazon-in-details --silent --output-dataset

```

## MCP server setup

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

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/yf176C9BhuzRqSMhz/builds/Dym6UDMdlDdxfj3IR/openapi.json