# Amazon Sales Estimator: Monthly Sales & Units Sold per ASIN (`vant47/amazon-sales-estimator`) Actor

Amazon sales estimate per US ASIN: monthly sales, units sold and revenue. $0.009/product. Estimates for about two thirds of products today (19/30 tested); coverage grows as more products are seen. Curves: Beauty, Health, Toys, Grocery, Pet Supplies. BSR, price, rating, reviews. No login.

- **URL**: https://apify.com/vant47/amazon-sales-estimator.md
- **Developed by:** [fortbrand](https://apify.com/vant47) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.20 / 1,000 product estimates

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Sales Estimator: Monthly Sales & Units Sold per ASIN

For Amazon US product research. Estimate monthly units and revenue from US ASINs or product URLs, for example protein powders or skincare products. Each row starts with an answer and its evidence.

**Estimates for about two thirds of products today; coverage grows as more products are seen.** In the 15 October 2026 test, 19/30 products received estimates and 28/30 returned ranks; every run completed. The sample covered 14 expected departments, with 20 products from the five calibrated departments and ten from others. It was not a random sample of the whole marketplace; your coverage may differ.

**About $0.009 per product estimate.** Twenty estimates cost about $0.18, plus the $0.00005 Actor start fee, before plan discounts. Duplicate products, unsupported inputs and products that cannot be estimated do not incur a product-estimate charge. No login. US only at launch.

These numbers are **estimates, not verified sales**. Amazon's purchase badge describes an approximate number of customers, not an audited count of units. This Actor uses that visible count as a conservative unit proxy under a one-unit-per-customer assumption. When no badge is visible, a qualifying category-specific BSR curve can provide an estimate. Neither method reveals a seller's actual orders or revenue.

### What you get

Example from 15 October 2026: "About 100,000 units/month (about $1,896,000); rank #30 in Beauty & Personal Care; scenario 100,000 to 200,000. Estimated, not verified sales." It used a 100K+ badge and $18.96 price. Prices and badges can change.

| Field | Meaning |
|---|---|
| `verdict` | Plain-English monthly units, revenue, rank and scenario range |
| `recordType` | `ESTIMATE`, `NOTE`, or `SUMMARY` |
| `asin`, `productUrl` | Requested Amazon US product and its canonical product link |
| `title`, `brand` | Product title and brand when publicly shown |
| `estimatedMonthlyUnits` | Indicative monthly units under the stated method and assumptions |
| `estimatedMonthlyRevenue` | Estimated units multiplied by the current displayed product price |
| `monthlyUnitsLow`, `monthlyUnitsHigh` | Illustrative unit scenario range, not a confidence interval |
| `monthlyRevenueLow`, `monthlyRevenueHigh` | The same scenarios multiplied by the displayed price |
| `method` | `amazon_badge_proxy` or `category_bsr_curve` |
| `methodNote`, `bandType` | Exact assumptions and interpretation of the range |
| `amazonBoughtBadge` | Original public badge text, such as `10K+ bought in past month` |
| `amazonBoughtCount` | Numeric displayed badge count, or null for a curve-only estimate |
| `badgeSource` | Optional product page; null when no badge was used |
| `bestSellerRank`, `bestSellerCategory` | First category rank shown in the product details |
| `bestSellerRanks` | All category/rank pairs extracted from the details |
| `curveCategory`, `calibrationSamples` | Category and distinct rank observations supporting a curve estimate |
| `price`, `currency` | Current public guest-catalog price, in USD |
| `rating`, `reviewsCount` | Public star rating and rating/review count, when shown |
| `sellerCount` | An explicit seller count, only when Amazon displays one |
| `offerCount` | Buying-options count when shown; offers are not necessarily distinct sellers |
| `soldBy`, `sellerId` | Main displayed seller details, if present |
| `imageUrl` | Main product image URL, when available |
| `parentAsin` | Parent variation identifier if exposed in the page |
| `checkedAt`, `modelVersion` | Observation time and method version |
| `rankSource`, `rankSourceUrl`, `priceSource` | Guest-catalog fallback provenance, when used |

Revenue is gross; fees, tax, discounts and returns are not deducted. Missing optional fields remain null. A missing price prevents a paid estimate because the requested revenue calculation would be unsupported. A readable title alone is not enough. If the Actor cannot obtain a product page, usable price or supported sales method, it returns a free `NOTE` explaining the limitation.

Dataset views show estimates and evidence. Every run writes `SUMMARY` and a self-contained `REPORT.html`, linked from its output tab.

### Start in three steps

1. Enter ASINs or US product URLs. The prefill requests one ASIN.
2. Check your maximum charge and start the Actor. Avoid overlapping Amazon jobs.
3. Open the dataset or HTML report. Inspect the method, badge and rank; export JSON or CSV if needed.

Each ASIN reads catalog rank and price, then makes one optional product-page request with a ten-second network deadline. An unavailable badge does not prevent a supported rank-based estimate.

### Inputs

| Input | Type | Default and behavior |
|---|---|---|
| `asins` | Array of strings | Optional ASIN list. Case is normalized. Up to 1,000 unique direct ASINs are considered. |
| `urls` | Array of strings | Optional `amazon.com` product URLs, including `/dp/`, `/gp/product/` and `/gp/aw/d/` forms. |
| `startUrls` | Array | Alias for product URLs; accepts request-list objects with a `url`. |
| `marketplace` | String | `US`. Other marketplaces receive a free note because their estimates are not calibrated. |

Each unique ASIN is processed and charged at most once per run. Keyword searches are not included at launch because Amazon search pages proved unreliable from the cloud.

Invalid ASINs, foreign URLs and unsupported marketplaces become free notes. The summary identifies a spending-limit stop. There is no separate free-plan cap. For long lists, increase the Apify run timeout.

Example direct input:

```json
{
  "asins": ["B00TTD9BRC", "B07RK4HST7"],
  "marketplace": "US"
}
```

### How the estimate is made

#### When Amazon shows a purchase badge

The raw badge is preserved. `10K+ bought in past month` becomes a displayed count of 10,000. The point estimate uses that displayed approximate customer count as a unit proxy, assuming one unit per customer. It does not silently turn the plus sign into an exact sales total.

The badge scenario range is one to two times the displayed count. This is an **illustrative sensitivity scenario**, not a statistically calibrated interval, an observed bucket boundary or a true upper bound. Actual unit sales can exceed the high scenario. The low number is also not a guaranteed lower bound on current monthly unit sales, because the source badge is approximate and its time window is not an audited calendar-month sales ledger.

Only a badge read from the current optional product page is presented as a current badge. Historical calibration observations are kept separate.

#### When only a best-seller rank is available

The Actor fits a robust log-log relationship between category rank and recent public purchase-badge counts. Each marketplace/category is separate. Only US observations are used at launch. The fitted number remains a customer-count proxy translated to units under the same one-unit assumption.

A curve requires eight distinct ranks, three badge levels and a rank span of at least three times. Shared ranks collapse to their median badge count. A robust median-slope fit reduces outlier influence. Non-decreasing, implausibly steep or excessively scattered relationships are rejected.

Variations can share ranks or badges, so their estimates are not independent sales totals. The Actor does not extrapolate beyond the observed rank range. When several category ranks are available, it uses the first qualifying in-range category. The scenario factor reflects the fit's observed log residuals, with a minimum factor of two. It is not an independently validated confidence interval, and fit quality against badges is not verified accuracy against real unit sales.

The named store `amazon-sales-estimator-us-curves-v1` retains observations for up to 30 days, deduplicated by ASIN. Each completed run merges new observations and refreshes its curves. A bundled seed supports new users; stale observations are rejected. Run one job at a time to avoid competing requests and calibration updates.

### Current department coverage

On 15 October 2026, the bundled calibration contains 153 real badge/rank observations. Qualifying department curves are available for **Beauty & Personal Care, Health & Household, Toys & Games, Grocery & Gourmet Food, and Pet Supplies**. Each curve applies only inside its observed rank range.

Other departments can receive estimates when a product-page badge is visible; otherwise they receive free notes. A department name alone does not guarantee an estimate. Coverage grows when buyer runs observe enough new badge/rank pairs. The run summary lists the curves that actually qualified for that run. New evidence can also disqualify a curve; coverage is not guaranteed to increase for every product.

### Price and spending limits

| Example | Base product-estimate charge |
|---|---:|
| One useful product | $0.009 |
| 20 useful products | $0.18 |
| 100 useful products | $0.90 |
| 1,000 useful products | $9.00 |

Add the small $0.00005 Actor start fee per run. Product-estimate prices are $0.00855 on Bronze, $0.00810 on Silver and $0.00720 on Gold and higher tiers. Platform usage is included in this Actor's event pricing.

A useful product is charged only when its estimate is delivered. Failed source requests, retries, duplicate products, unsupported categories, unsupported marketplaces, invalid inputs and summary rows have no product-estimate charge. The Actor checks your remaining charge allowance before fetching the next product and stops cleanly when another estimate would exceed it. The start fee still applies to a run that only returns notes.

### Use with AI agents (MCP)

Connect your assistant to Apify's MCP server at `https://mcp.apify.com`. A useful request is: "Use vant47/amazon-sales-estimator to estimate monthly sales and revenue for these US Amazon ASINs. Return the scenario range, raw badge and method with each estimate. Set a maximum run charge."

Ask your agent to retain the method, raw evidence and uncertainty notes with every result.

### API examples

Keep tokens outside code and Actor inputs. Python:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("vant47/amazon-sales-estimator").call(
    run_input={"asins": ["B00TTD9BRC"], "marketplace": "US"},
    max_total_charge_usd=0.10,
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

JavaScript:

```javascript
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("vant47/amazon-sales-estimator").call(
  { asins: ["B00TTD9BRC"], marketplace: "US" },
  { maxTotalChargeUsd: 0.10 }
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

For larger lists, use an asynchronous REST run and poll its status. Export CSV, Excel or JSON, or connect Make, Zapier, n8n or a webhook. Separate scheduled runs so they do not overlap.

### Reliability and limits

The initial 15 October retail-page matrix passed 50/50 products. Later validation exposed renewed page refusals. Launch therefore uses the guest catalog as the required source and product badges only as an optional enhancement. Keyword mode was removed.

Rank, category and price come from Amazon's public signed-out Revenue Calculator catalog, matched to the exact ASIN. Optional retail pages supply badges and brand details. Catalog requests are serial, at least three seconds apart, with fresh retry sessions, datacenter first and residential only from the third attempt. The optional badge request gets one datacenter attempt. Retries wait 3, 8, 15 and 30 seconds and honor Retry-After. It does not log in, reuse account cookies, solve CAPTCHAs or call a paid external data API. Amazon can still refuse a request or change its markup.

Optional fields depend on the response. Offer counts are separate from distinct seller counts. Delivery region and variation can affect prices. Missing badges, ranks, prices and calibration coverage remain explicit limitations.

No affiliation with Amazon or access to audited orders, sales history or seller inventory.

### FAQ

**Are these exact sales?** No. Badges approximate customers; curves predict badge proxies. Neither exposes actual orders.

**Does 10K+ mean exactly 10,000 units?** No. The displayed number becomes a conservative proxy under the stated one-unit assumption.

**Is the range a confidence interval?** No. It is an illustrative scenario and does not bound actual sales.

**Why did I get a free note?** A required page, current price, badge or supported in-range curve was unavailable.

**Can I use another marketplace?** US only at launch. Other marketplaces receive free notes.

**Can I search by keyword?** No. Launch supports ASINs and US product URLs only.

**Do duplicates cost extra?** No. Each unique product is charged once within a run.

**Do I need Amazon credentials?** No. Do not supply account cookies or passwords.

Amazon sales estimate, Amazon monthly sales, units sold per ASIN, estimated revenue, public purchase badges and category BSR, with the evidence and limitations kept together.

# Actor input Schema

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

US ASINs, e.g. B00TTD9BRC. Uses a visible badge or supported in-range department curve; otherwise a free note. Launch curves: Beauty, Health, Toys, Grocery and Pet Supplies. Up to 1,000 unique ASINs.

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

Optional amazon.com product URLs. Duplicates are free.

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

US only at launch. Other marketplaces return a free note.

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

Optional US product URLs, alias for urls.

## Actor input object example

```json
{
  "asins": [
    "B00TTD9BRC"
  ],
  "marketplace": "US"
}
```

# Actor output Schema

## `estimates` (type: `string`):

No description

## `evidence` (type: `string`):

No description

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

No description

## `report` (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": [
        "B00TTD9BRC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/amazon-sales-estimator").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": ["B00TTD9BRC"] }

# Run the Actor and wait for it to finish
run = client.actor("vant47/amazon-sales-estimator").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": [
    "B00TTD9BRC"
  ]
}' |
apify call vant47/amazon-sales-estimator --silent --output-dataset

```

## MCP server setup

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

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/as4nC8X9IrrA0cgvt/builds/5nVG8Lw6hXQIODLeS/openapi.json