# Amazon Seller Analyzer | Sales & Revenue | $5/1K (`apivault_labs/amazon-seller-revenue-strategy-analyzer`) Actor

Amazon Seller Analyzer estimates competitor sales and revenue by day, month, and year. Run fast bulk seller analysis with no Amazon login or cookies required, product-level ranges, Buy Box signals, strategy tracking, JSON/CSV/Excel exports, and API access. $5/1K products plus $0.01/run.

- **URL**: https://apify.com/apivault\_labs/amazon-seller-revenue-strategy-analyzer.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** E-commerce, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 70.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product analyzeds

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?

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

<p align="center">
  <a href="https://apify.com/apivault_labs/amazon-seller-revenue-strategy-analyzer">
    <img src="https://api.apify.com/v2/key-value-stores/9lBrSnBjCV1tHsJNS/records/amazon-seller-revenue-analyzer-hero.png?signature=12zCv33X65KsAafggVQ8z" alt="Amazon Seller Revenue and Strategy Analyzer dashboard" width="100%">
  </a>
</p>

<p align="center">
  <strong>Amazon Seller Analyzer estimates competitor sales, revenue, product leaders, and visible strategy changes from one seller profile.</strong>
</p>

<p align="center">
  <a href="https://apify.com/apivault_labs/amazon-seller-revenue-strategy-analyzer"><strong>Analyze an Amazon seller →</strong></a>
</p>

### What is Amazon Seller Analyzer?

**Amazon Seller Analyzer** turns public Amazon seller information into a structured competitor-intelligence report. Add a seller ID or profile URL to estimate **daily, monthly, and annual unit sales and revenue**, see which products may drive the business, and monitor observable changes between runs.

The Actor is designed for Amazon sellers, agencies, wholesalers, aggregators, researchers, and sourcing teams. It supports fast bulk seller analysis with **no Amazon login, cookies, Seller Central access, or third-party API key required**.

You receive:

- estimated seller sales for a day, month, and year;
- estimated revenue with low, expected, and high scenarios;
- product-level sales and revenue attribution;
- price, availability, Best Sellers Rank, Prime, coupon, offer, and Buy Box signals when publicly visible;
- seller profile and catalog coverage information;
- strategy-change events on recurring runs;
- structured JSON records ready for CSV, Excel, API, Make, n8n, or a data warehouse.

### What can you use it for?

| Use case | Business question |
|---|---|
| Competitor benchmarking | How large might this seller be? |
| Product research | Which listings appear to generate the most demand? |
| Wholesale research | How much listing demand may belong to the target seller? |
| Seller due diligence | Is the visible catalog large and commercially active? |
| Portfolio monitoring | What changed in price, availability, rank, promotions, or seller position? |
| Reporting and automation | How can I feed Amazon competitor data into my existing workflow? |

### How to analyze an Amazon seller

1. Open the Actor and paste an Amazon seller ID or seller profile URL.
2. Choose the matching Amazon marketplace.
3. For your first run, set **Products per seller** to `10`.
4. Run the Actor and open the **Analysis results** output.
5. Review the `seller_summary` row first, then compare the related `product` rows.
6. Schedule repeated runs with **Track changes** enabled to detect observable strategy changes.

#### Example input

```json
{
  "sellerIds": ["A294P4X9EWVXLJ"],
  "marketplace": "us",
  "maxProductsPerSeller": 10,
  "includeOffers": true,
  "trackStrategy": true
}
```

You can provide multiple seller IDs or URLs in one run. Each seller is analyzed independently in the selected marketplace.

### Input options

| Field | Type | Default | Description |
|---|---|---:|---|
| `sellerUrls` | array | — | Amazon seller profile URLs containing a seller ID. |
| `sellerIds` | array | — | Amazon merchant IDs. Use this when you already know the seller ID. |
| `marketplace` | string | `us` | Marketplace used for catalog discovery, prices, and currency. |
| `maxProductsPerSeller` | integer | `10` | Maximum unique products analyzed for each seller, from 1 to 500. |
| `includeOffers` | boolean | `true` | Inspect public offer and Buy Box information for better seller attribution. |
| `trackStrategy` | boolean | `true` | Compare observable signals with the previous successful run. |
| `maxConcurrency` | integer | `4` | Parallel product processing. This load-tested value balances speed and reliability. |
| `proxyConfiguration` | object | Apify Residential | Proxy configuration used for marketplace requests. |

At least one valid value in `sellerUrls` or `sellerIds` is required.

#### Supported Amazon marketplaces

| Input | Marketplace | Currency |
|---|---|---|
| `us` | United States | USD |
| `uk` | United Kingdom | GBP |
| `de`, `fr`, `es`, `it` | Germany, France, Spain, Italy | EUR |
| `ca` | Canada | CAD |
| `mx` | Mexico | MXN |
| `in` | India | INR |

### Amazon seller revenue data

The default Dataset uses three `rowType` values:

| `rowType` | What it contains |
|---|---|
| `seller_summary` | Seller-level headline estimates, ranges, catalog coverage, and profile data. |
| `product` | Listing data and the estimated portion attributed to the target seller. |
| `strategy_action` | A detected difference from the seller's previous observation. |

Important seller summary fields:

| Field | Meaning |
|---|---|
| `estimatedSalesDaily` | Expected units sold per day across analyzed products. |
| `estimatedSalesMonthly` | Expected units sold per 30-day month. |
| `estimatedSalesAnnual` | Monthly estimate projected across 12 months. |
| `estimatedRevenueDaily` | Expected daily gross merchandise revenue in local currency. |
| `estimatedRevenueMonthly` | Expected monthly gross merchandise revenue. |
| `estimatedRevenueAnnual` | Monthly estimate projected across 12 months. |
| `estimatedRevenueMonthlyLow` / `High` | Lower and upper monthly scenarios. |
| `productsAnalyzed` | Number of unique products included in the estimate. |
| `dataCoverageScore` | Relative completeness of observable signals, from 0 to 100. |

#### Example seller summary

```json
{
  "rowType": "seller_summary",
  "sellerId": "A294P4X9EWVXLJ",
  "sellerName": "AnkerDirect",
  "marketplace": "us",
  "currency": "USD",
  "productsAnalyzed": 2,
  "estimatedSalesDaily": 3.9,
  "estimatedSalesMonthly": 117,
  "estimatedSalesAnnual": 1404,
  "estimatedRevenueDaily": 62.36,
  "estimatedRevenueMonthly": 1870.83,
  "estimatedRevenueAnnual": 22449.96,
  "estimatedRevenueMonthlyLow": 505.53,
  "estimatedRevenueMonthlyHigh": 8278.67,
  "dataCoverageScore": 78
}
```

The values above illustrate the output format from a limited test. They are not a claim about the seller's current or actual revenue.

### Track visible Amazon competitor strategy

Keep **Track changes** enabled and run the same seller and marketplace repeatedly. From the second successful observation onward, the Actor can report changes such as:

- products appearing in or disappearing from the visible catalog;
- price increases and decreases;
- coupon or promotion changes;
- availability changes;
- Best Sellers Rank movement;
- Buy Box or seller-position changes.

Use a daily schedule for closely watched competitors or a weekly schedule for broader portfolio research. A change event describes a public marketplace observation; it does not reveal a seller's private business decision.

### How much does an Amazon seller analysis cost?

This Amazon Seller Analyzer uses transparent **pay per event (PPE)** pricing. Product analysis costs up to **$5 per 1,000 successfully analyzed products**, with lower prices for paid Apify plans, plus a $0.01 Actor start charge:

| Apify plan | Per product | Per 1,000 products |
|---|---:|---:|
| FREE | `$0.005` | **$5.00** |
| BRONZE | `$0.004` | **$4.00** |
| SILVER | `$0.0035` | **$3.50** |
| GOLD | `$0.003` | **$3.00** |
| PLATINUM | `$0.0025` | **$2.50** |
| DIAMOND | `$0.002` | **$2.00** |

The Actor start costs **$0.01 per run**. Seller summaries and detected strategy events are free.

Estimated Actor event charges:

| Products analyzed | FREE | BRONZE | DIAMOND |
|---:|---:|---:|---:|
| 10 | `$0.06` | `$0.05` | `$0.03` |
| 50 | `$0.26` | `$0.21` | `$0.11` |
| 100 | `$0.51` | `$0.41` | `$0.21` |
| 500 | `$2.51` | `$2.01` | `$1.01` |

**User pays platform usage costs: Yes.** Apify platform usage is charged separately to the user. This can include compute, storage, data transfer, and residential proxy traffic according to the user's Apify plan. Actual total cost depends on the marketplace, catalog size, public page availability, and run configuration. Start with 10 products to measure cost and coverage before increasing the limit.

### API and integrations

Run the Actor from the Apify API:

```bash
curl "https://api.apify.com/v2/acts/apivault_labs~amazon-seller-revenue-strategy-analyzer/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "sellerIds": ["A294P4X9EWVXLJ"],
    "marketplace": "us",
    "maxProductsPerSeller": 10
  }'
```

After the run finishes, use the run's default Dataset URL to retrieve JSON, CSV, Excel, XML, or HTML. You can also connect the Actor to schedules, webhooks, Make, Zapier, n8n, Google Sheets, or your own application.

### Accuracy and responsible use

Amazon does not publish a competitor's private Seller Central sales or accounting data. Therefore, this Actor provides **model-based estimates from publicly observable marketplace signals**, not audited figures or guaranteed actual sales.

For responsible interpretation:

- use low, expected, and high scenarios instead of relying on one number;
- compare sellers using the same marketplace and similar product limits;
- check `dataCoverageScore` and `productsAnalyzed` before drawing conclusions;
- treat annual figures as projections, not historical financial statements;
- do not use the results as the sole basis for investment, credit, legal, or acquisition decisions.

Results may vary because Amazon pages, rankings, offers, availability, and visible catalogs change over time. Use the Actor in accordance with applicable laws, Amazon's terms, and Apify's policies.

### Troubleshooting

#### The Actor found no analyzable products

Confirm that the seller ID belongs to the selected marketplace. Some profiles do not expose a public catalog, and some products may be unavailable at the time of the run.

#### Revenue looks lower than total listing demand

Amazon listings can have multiple sellers. Product demand and the portion attributed to the target seller are different measurements.

#### No strategy changes were returned

The first successful tracked run creates a baseline. Changes can appear only after a later run observes a difference for the same seller and marketplace.

#### The run is slow or incomplete

Keep the default concurrency and proxy settings, lower the product limit, and retry. Public marketplace pages can respond differently across marketplaces and times.

### FAQ

#### Are the sales and revenue figures exact?

No. Exact competitor sales are private. The Actor returns transparent estimate ranges and coverage indicators to make uncertainty visible.

#### Does it require an Amazon login or API key?

No. You only need an Amazon seller ID or seller profile URL.

#### Can I analyze several sellers at once?

Yes. Add multiple IDs or URLs. The selected product limit applies to each seller.

#### Can I export the results?

Yes. Apify Datasets support JSON, CSV, Excel, XML, and HTML exports as well as API access.

#### Where can I report an issue?

Open the **Issues** tab on the Actor page and include the marketplace, seller ID, and run ID. Do not post API tokens or private credentials.

***

<p align="center">
  <strong>Benchmark an Amazon seller in minutes.</strong><br><br>
  <a href="https://apify.com/apivault_labs/amazon-seller-revenue-strategy-analyzer"><strong>Run Amazon Seller Analyzer →</strong></a>
</p>

# Actor input Schema

## `sellerUrls` (type: `array`):

Add Amazon seller profile URLs that contain a seller parameter, for example an /sp?seller=... URL.

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

Add Amazon merchant IDs directly. A seller ID normally contains 13–14 uppercase letters and numbers.

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

Choose the marketplace where the seller operates. This controls catalog discovery, local prices, and output currency.

## `maxProductsPerSeller` (type: `integer`):

Maximum number of unique products analyzed for each seller. Billing applies only to products successfully analyzed.

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

Inspect publicly visible offer and Buy Box information for better attribution of listing demand to the target seller.

## `trackStrategy` (type: `boolean`):

Save an observation baseline and compare visible price, rank, availability, promotion, and seller-position signals on later runs.

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

Number of products processed in parallel. The load-tested value balances speed and marketplace reliability.

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

Apify Residential Proxy is recommended for reliable marketplace access. Proxy traffic is billed by Apify as platform usage.

## Actor input object example

```json
{
  "sellerIds": [
    "A294P4X9EWVXLJ"
  ],
  "marketplace": "us",
  "maxProductsPerSeller": 2,
  "includeOffers": true,
  "trackStrategy": true,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `analysisResults` (type: `string`):

All seller summary, product, and strategy event rows from the run.

## `sellerSummaries` (type: `string`):

Compact run-level JSON containing completed seller summaries.

# 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 = {
    "sellerIds": [
        "A294P4X9EWVXLJ"
    ],
    "maxProductsPerSeller": 2,
    "includeOffers": false,
    "trackStrategy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/amazon-seller-revenue-strategy-analyzer").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 = {
    "sellerIds": ["A294P4X9EWVXLJ"],
    "maxProductsPerSeller": 2,
    "includeOffers": False,
    "trackStrategy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/amazon-seller-revenue-strategy-analyzer").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 '{
  "sellerIds": [
    "A294P4X9EWVXLJ"
  ],
  "maxProductsPerSeller": 2,
  "includeOffers": false,
  "trackStrategy": false
}' |
apify call apivault_labs/amazon-seller-revenue-strategy-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/amazon-seller-revenue-strategy-analyzer"
        }
    }
}

```

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/NFIKGWdTAHRznHrUZ/builds/8ENwthAhfIQqGnRpd/openapi.json