# Amazon ASIN Collector (`apt_marble/amazon-asin-collector`) Actor

Build one clean, deduplicated list of Amazon ASINs from many places at once — search terms, Best Seller charts, seller storefronts and any Amazon listing link. Every ASIN says which source found it, caps keep the run bounded, and full product details can be attached on demand.

- **URL**: https://apify.com/apt\_marble/amazon-asin-collector.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 asin collecteds

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 ASIN Collector

Build one clean list of Amazon product identifiers from many places at once.
Point the actor at search terms, Best Seller charts, seller storefronts and any
other Amazon listing link, and it walks all of them in a single run, merges
everything into one deduplicated list, and tells you which source found each
product. It is the fastest way to assemble the ASIN list that feeds everything
else — repricing, sourcing, advertising, competitive tracking — without
stitching four exports together by hand.

### What you can do with it

- **Assemble a working ASIN list.** Combine several search terms, a couple of
  charts and a competitor's storefront into one list with no duplicates.
- **Map a competitor's catalogue.** Collect every product a seller lists, with
  its position in their storefront.
- **Snapshot a category's top sellers.** Pull the full Best Sellers ranking,
  including the ranked positions Amazon does not display in full.
- **Feed downstream work.** Export ASINs straight into pricing, review or
  advertising tools.
- **See which source found what.** Every row records the source and the exact
  keyword, chart or seller behind it, so you can weigh sources against each
  other.
- **Go deeper when you need to.** Switch on full product details to attach the
  complete product record — specifications, images, the full star breakdown and
  category rankings — to each collected ASIN.

Fill in as many of the four source groups as you like; at least one must have
something in it. Caps keep the run bounded: one for how much any single source
may contribute, and one for how many unique products the whole run collects.

### What you get

One row per unique product. A product found by three sources appears once,
attributed to the first source that found it. Abridged sample:

```json
{
  "asin": "B08JHCVHTY",
  "source": "chart",
  "sourceDetail": "electronics",
  "sourceUrl": "https://www.amazon.com/gp/bestsellers/electronics/",
  "marketplace": "us",
  "position": 1,
  "rank": 1,
  "url": "https://www.amazon.com/dp/B08JHCVHTY",
  "title": "Blink Plus Plan with monthly auto-renewal",
  "price": 12.0,
  "currency": "USD",
  "listPrice": null,
  "rating": 4.5,
  "ratingsCount": 18422,
  "image": "https://m.media-amazon.com/images/I/31YHGbJsldL._AC_UL300_.jpg",
  "isPrime": true,
  "isSponsored": false,
  "detailLevel": "full",
  "detailsIncluded": false,
  "collectedAt": "2026-08-07T09:14:02.881Z"
}
```

With **Include full product details** switched on, the same row also carries
`brand`, `availability`, `inStock`, `buyBoxSeller`, `shipsFrom`,
`bestSellersRank`, `featureBullets`, `specifications`, `breadcrumbs`, `images`,
`starHistogram`, `description`, `dimensions`, `weight`, `hasCoupon` and
`dateFirstAvailable`, and `detailsIncluded` becomes `true`.

### Input reference

| Setting | Type | Default | Description |
| --- | --- | --- | --- |
| Search keywords | list of text | — | Collect products from the results of these searches. |
| Best Seller categories | multi-select | — | Collect products from these Best Sellers charts. |
| Seller storefronts | list of text | — | Collect products from these sellers' catalogues. Storefront links or bare seller IDs. |
| Any Amazon listing links | list of text | — | Collect products from any other Amazon search, category or chart link. |
| Maximum ASINs per source | integer | `500` | Stop after this many products from each individual source. |
| Maximum ASINs in total | integer | `2000` | Stop the whole run once this many unique products have been collected. |
| Include title and price | yes/no | `yes` | Return the title, price and rating shown alongside each product in the listing it came from. Free — it is already there. |
| Include full product details | yes/no | `no` | Attach the complete product record to every collected product. Much slower and billed separately. |
| Amazon marketplace | select | `us` | Which country's Amazon site to read. Results come back in that marketplace's own currency. |
| Parallel targets | integer | `4` | How many sources to work on at the same time. Higher is faster, but Amazon serves fewer complete results when pushed hard. Leave at 4 unless you have a reason. |

At least one of the four source groups must be filled in. If none is, the run
stops immediately and says so.

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `asin` | string | Amazon's product identifier. Unique across the whole run. |
| `source` | string | Which kind of source found it: `search`, `chart`, `storefront` or `url`. |
| `sourceDetail` | string | The exact keyword, chart, seller or link behind it. |
| `sourceUrl` | string | The Amazon listing this product was found in. |
| `marketplace` | string | The Amazon marketplace it was collected from. |
| `position` | integer | Where it appeared in that listing. |
| `rank` | integer | null | Chart rank, for products found in a Best Sellers chart. `null` elsewhere. |
| `url` | string | Clean link to the product, free of tracking. |
| `title` | string | null | Product title as shown in the listing. |
| `price` | number | null | Price as shown in the listing. `null` where the listing published none. |
| `currency` | string | null | Currency the price was published in, read from Amazon itself. |
| `listPrice` | number | null | Struck-through list price, when the listing shows one. |
| `rating` | number | null | Average star rating out of 5. |
| `ratingsCount` | integer | null | How many customers rated it. |
| `image` | string | null | Product image shown in the listing. |
| `isPrime` | boolean | null | Prime eligibility as shown in the listing. |
| `isSponsored` | boolean | null | Whether it was a paid placement in the listing it came from. |
| `detailLevel` | string | `full` when the listing published the product's details, `rank-only` for a chart entry Amazon ranks without displaying. |
| `detailsIncluded` | boolean | Whether the complete product record was attached to this row. |
| `collectedAt` | string | ISO timestamp of collection. |

### Pricing

Pay-per-event. You are billed for what you actually receive.

| You are charged | When |
| --- | --- |
| **$0.50 per 1,000 ASINs** | For every unique product written to the dataset. A product found by several sources is written, and charged, once. |
| **$1.20 per 1,000 full product records** | Only when *Include full product details* is on, and only for products whose complete record was successfully attached. |

**Worked example.** Four search terms and two Best Sellers charts, capped at
2,000 unique products, costs **$1.00**. Turn on full product details and those
same 2,000 rows carry the complete product record for **$3.40** in total.
Products whose deeper record could not be collected are still delivered, still
flagged, and are not charged the second event.

### Limits & what this actor cannot do

- Amazon publishes a limited set of public results for any one search,
  storefront or chart. A search or storefront yields a few hundred products at
  most, and a Best Sellers chart is exactly one hundred ranked positions. A
  higher limit returns what Amazon actually makes available rather than an
  unlimited catalogue, and the run says up front how many products your sources
  can reach.
- A Best Sellers chart ranks one hundred products but displays the details of
  only some of them. The rest come back with their rank and identifier and an
  empty title and price, marked `rank-only`, rather than being silently
  dropped. Switch on full product details to fill them in.
- Seller storefronts do not publish prices. Products collected from a
  storefront come back with an empty price — that is what Amazon shows, not a
  collection failure. Switch on full product details if you need prices for
  them.
- Some charts, such as Movers & Shakers, are genuinely empty at times. An empty
  chart is reported as an empty chart, not retried as an error.
- Prices, ranks, ratings and stock are a snapshot at the moment of collection
  and keep changing afterwards.
- Prices and availability differ between Amazon marketplaces; results reflect
  the marketplace you select, in that marketplace's own currency.
- Products that are removed, restricted or unavailable in the selected
  marketplace are reported as unavailable rather than returned empty.
- Sponsored placements appear inside Amazon's own search results; they are
  flagged so they can be filtered out afterwards.
- Customer questions and answers are not publicly listed and are not returned.
- Speed depends on the size of the job and on Amazon's own response times; no
  fixed throughput is promised.
- Amazon's terms govern automated access. You are responsible for using the
  data lawfully and in line with the source site's terms, and for handling any
  personal data in line with applicable privacy law.

### FAQ

**Do I need an Amazon account?**
No. The actor only reads what Amazon publishes to anyone.

**Does it need my login or password?**
No, and there is nowhere to enter one.

**Can I schedule it?**
Yes. Schedule it on Apify like any other actor and diff the lists over time to
see what entered or left a category.

**Is the data complete?**
It is complete for what Amazon publicly lists. Each source has its own ceiling
— a few hundred products for a search or a storefront, exactly one hundred for
a chart — and the run reports the reachable total before it starts, so you
always know what a given set of sources can produce.

**What happens if the same product appears in two sources?**
It is written once and attributed to the first source that found it, and it is
billed once. The per-source counts in the run summary show how much each source
actually contributed.

**Why do some rows have no title or price?**
Two honest reasons. Best Sellers charts rank more products than they display,
so the undisplayed ones arrive as `rank-only`. And seller storefronts publish
no prices at all. Turning on full product details fills in both.

# Actor input Schema

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

Collect ASINs from the results of these searches.

## `categories` (type: `array`):

Collect ASINs from these Best Sellers charts.

## `sellerIds` (type: `array`):

Collect ASINs from these sellers' catalogues. Storefront links or bare seller IDs.

## `urls` (type: `array`):

Collect ASINs from any other Amazon search, category or chart links.

## `maxAsinsPerSource` (type: `integer`):

Stop after this many ASINs from each individual source.

## `maxTotalAsins` (type: `integer`):

Stop the whole run once this many unique ASINs have been collected.

## `includeBasicData` (type: `boolean`):

Return the title, price and rating shown alongside each ASIN in the listing it came from. Free — this is already on the page.

## `includeProductDetails` (type: `boolean`):

Open each collected ASIN to collect the complete product record — full specifications, every image, the full rating breakdown and category rankings. Much slower and billed separately; leave off for a fast list.

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

Which country's Amazon site to read. Prices, availability and rankings differ between marketplaces, and results come back in that marketplace's own currency.

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

How many targets to work on at the same time. Higher is faster but Amazon serves fewer complete pages when pushed hard. Leave at 4 unless you have a reason.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "maxAsinsPerSource": 100,
  "maxTotalAsins": 2000,
  "includeBasicData": true,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}
```

# Actor output Schema

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

Every row this run produced.

## `runSummary` (type: `string`):

What this run collected, and anything it could not read.

# 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 = {
    "keywords": [
        "wireless earbuds"
    ],
    "maxAsinsPerSource": 100,
    "maxTotalAsins": 2000,
    "includeBasicData": true,
    "includeProductDetails": false,
    "marketplace": "us",
    "maxConcurrency": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/amazon-asin-collector").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 = {
    "keywords": ["wireless earbuds"],
    "maxAsinsPerSource": 100,
    "maxTotalAsins": 2000,
    "includeBasicData": True,
    "includeProductDetails": False,
    "marketplace": "us",
    "maxConcurrency": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/amazon-asin-collector").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 '{
  "keywords": [
    "wireless earbuds"
  ],
  "maxAsinsPerSource": 100,
  "maxTotalAsins": 2000,
  "includeBasicData": true,
  "includeProductDetails": false,
  "marketplace": "us",
  "maxConcurrency": 4
}' |
apify call apt_marble/amazon-asin-collector --silent --output-dataset

```

## MCP server setup

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

```

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/s7nDgi1shNkzOrRU7/builds/PAUjD2ij61qpqV9RQ/openapi.json