# Amazon Offers & Sellers Scraper: Hijacker & Buy Box Alerts (`vant47/amazon-offers-hijackers`) Actor

Find hijackers and unauthorized sellers on your Amazon listings, e.g. a brand checking its ASINs daily or an agency auditing a client's catalog. About $0.03 per ASIN, no login. Verdict first, then the Buy Box winner and every offer: seller, ID, price, shipping, FBA/FBM, rating, authorized flag.

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

## Pricing

from $24.00 / 1,000 asin checks

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 Offers & Sellers Scraper: Hijacker & Buy Box Alerts

For Amazon brand owners, brand-protection agencies and authorized resellers who need to know who else is selling their products: hijackers, unauthorized sellers and MAP breakers, ASIN by ASIN.

**About $0.03 per ASIN. Checking 20 ASINs costs about $0.60.** No login, no Amazon seller account, no API key.

Give it your ASINs and your brand name (or your seller IDs). For each ASIN you get one row that starts with a plain-English verdict, for example:

> 3 unauthorized sellers on B0XXXXXXXX, the cheapest 12% under your price ($17.59 vs $19.99), Buy Box held by GoodDeals (unauthorized). 1 new seller since the last run: ShopZ.

Then every offer on the listing: seller name, seller ID, price, shipping, condition, FBA or FBM, Buy Box winner, seller rating and rating count, an authorized yes/no flag and counterfeit-risk signs. Schedule it daily and it becomes a hijacker alert feed: each run reports new sellers, sellers that left and Buy Box changes since the run before.

Not affiliated with, endorsed or sponsored by Amazon. It reads the public offer list that any shopper sees under "Other sellers on Amazon".

### What you get

| Field | What it tells you |
|---|---|
| `verdict` | One sentence: how many unauthorized sellers, how far under your price the cheapest is, who holds the Buy Box, what changed |
| `status` | `unauthorized sellers`, `clean`, `checked` (no authorized list given), `no offers`, `not found` |
| `alert` | `true` when there is an unauthorized seller, a new seller, a lost Buy Box, an offer under your MAP or a high counterfeit risk |
| `buyBoxSeller`, `buyBoxSellerId`, `buyBoxPrice` | Who wins the Buy Box (the featured offer) and at what price |
| `buyBoxAuthorized`, `buyBoxSuppressed` | Whether the Buy Box winner is yours, and whether Amazon shows no featured offer at all |
| `unauthorizedSellerCount`, `unauthorizedSellers` | Count and list: name, seller ID and price |
| `lowestUnauthorizedPrice`, `referencePrice` | The cheapest unauthorized offer and the price it is compared with (your MAP, your own offer or the Buy Box) |
| `newSellersSinceLastRun`, `sellersGoneSinceLastRun`, `buyBoxChangedSinceLastRun` | Changes since the previous run with the same history storage |
| `belowMapSellerCount` | Sellers under the MAP price you gave |
| `counterfeitRiskHigh`, `counterfeitRiskMedium` | Offers with strong or some counterfeit-risk signs |
| `offers[]` | Every offer: `sellerName`, `sellerId`, `authorized`, `isBuyBox`, `price`, `shipping`, `totalPrice`, `priceGapPct`, `priceHidden`, `belowMap`, `condition`, `fulfillment` (FBA, FBM or Amazon), `shipsFrom`, `sellerRating`, `sellerRatingsCount`, `sellerPositivePct`, `newSellerBadge`, `newSinceLastRun`, `firstSeen`, `counterfeitRisk`, `riskReasons`, `deliveryEstimate`, `sellerUrl` |
| `productTitle`, `productRating`, `productRatingsCount`, `image`, `productUrl` | The listing itself |

Every run also saves:

- **REPORT.html**: one page per run with the verdicts and a colour-coded offer table per ASIN (authorized, unauthorized, risk), ready to send to a client.
- **OFFERS.csv**: one line per offer across all ASINs, for Excel or Google Sheets.
- **SUMMARY**: what each ASIN returned, what was charged and any skipped inputs.

### Use cases

- **Hijacker alerts.** A brand checks its 50 hero ASINs every morning and gets told the day a new seller jumps on a listing.
- **Unauthorized reseller audits.** An agency runs a client's whole catalog once and hands over the list of sellers who are not on the approved list, with seller IDs ready for a takedown or a test buy.
- **MAP enforcement.** Give your MAP price and see every offer under it, including sellers that hide their price until checkout.
- **Buy Box monitoring.** Know when the Buy Box leaves your store, who took it and at what price, or when Amazon suppresses it.
- **Counterfeit triage.** New sellers, sellers far under your price and sellers with few or poor ratings are flagged first, so you test-buy from the right ones.

### How to use it

1. **Add your ASINs.** Paste ASINs (B0D5CLSMFB) or product links (https://www.amazon.com/dp/B0D5CLSMFB) into **ASINs or Amazon product links**.
2. **Say who is authorized.** Type your brand in **Your brand name** (Anker matches AnkerDirect and Anker Official), or list seller IDs or exact store names in **Your authorized sellers**. Amazon itself counts as authorized unless you switch that off.
3. **Run it, then schedule it.** Read the verdicts in the Output tab or open REPORT.html. To get daily alerts, create a schedule (Saved tasks > Schedule) and keep **Track changes between runs** on.

### Input

| Field | Example | Notes |
|---|---|---|
| `asins` | `["B0D5CLSMFB", "https://www.amazon.co.uk/dp/B07C5R51Q9"]` | ASINs or product links; links from other Amazon stores are checked on that store |
| `myBrand` | `"Anker"` | Sellers whose store name contains it count as authorized; several brands separated by commas |
| `mySellerIds` | `["A294P4X9EWVXLJ", "My Reseller LLC"]` | Seller IDs (the `seller=` part of a store link) or exact store names |
| `marketplace` | `"US"` | US, UK, DE, FR, IT, ES, CA or AU, for plain ASINs |
| `mapPrice` | `24.99` | Optional MAP for every ASIN |
| `mapPrices` | `{"B0D5CLSMFB": 21.99}` | Optional MAP per ASIN |
| `condition` | `"new"` | `new` (default, where hijackers sell) or `all` (used and renewed too) |
| `trackChanges` | `true` | Keep a seller history so the next run reports what changed |
| `historyStoreName` | `"amazon-offers-history"` | Use one name per brand or client |
| `maxOffersPerAsin` | `100` | Most listings have under 30 offers |
| `amazonIsAuthorized` | `true` | Treat offers sold by Amazon as authorized |

With neither a brand nor seller IDs, the run still lists every seller, the Buy Box and the counterfeit-risk signs, but cannot say who is unauthorized. Invalid entries become free note rows; they never fail the run.

### Output example

A real row from 13 October 2026 (prefilled input, brand "Anker"; the reseller's name and ID are replaced here):

```json
{
  "verdict": "1 unauthorized seller on B0D5CLSMFB, the cheapest at $44.99 (not under your price), Buy Box held by AnkerDirect at $20.89.",
  "status": "unauthorized sellers",
  "alert": true,
  "asin": "B0D5CLSMFB",
  "marketplace": "US",
  "buyBoxSeller": "AnkerDirect",
  "buyBoxSellerId": "A294P4X9EWVXLJ",
  "buyBoxPrice": 20.89,
  "buyBoxAuthorized": true,
  "buyBoxFulfillment": "FBA",
  "sellerCount": 2,
  "offerCount": 3,
  "unauthorizedSellerCount": 1,
  "unauthorizedSellers": ["Reseller X (A1XXXXXXXXXXXX) $44.99"],
  "referencePrice": 20.89,
  "referencePriceType": "your price",
  "lowestUnauthorizedPrice": 44.99,
  "currency": "USD",
  "newSellersSinceLastRun": [],
  "offers": [
    {
      "sellerName": "Reseller X",
      "sellerId": "A1XXXXXXXXXXXX",
      "authorized": false,
      "isBuyBox": false,
      "price": 44.99,
      "shipping": 0,
      "condition": "New",
      "fulfillment": "FBM",
      "sellerRating": 4.5,
      "sellerRatingsCount": 102,
      "sellerPositivePct": 90,
      "counterfeitRisk": "none",
      "riskReasons": []
    }
  ]
}
```

### How "unauthorized" is decided

An offer is **authorized** when its seller ID or exact store name is in `mySellerIds`, when its store name contains your brand (`myBrand`), or when Amazon itself sells it (Amazon.com, Amazon EU, Amazon Resale) and `amazonIsAuthorized` is on. Every other seller is **unauthorized**. The verdict compares the cheapest unauthorized offer with, in this order: your MAP, your own lowest offer, the Buy Box price, the median price.

### Counterfeit-risk signs

Each offer that is not yours gets `counterfeitRisk` (high, medium, low or none) and the reasons in plain words:

- Amazon labels the seller "New Seller" or "Just launched", or it has very few ratings
- Positive feedback under 80%
- Price 5%, 15% or 30% under the reference price
- Price hidden until the item is in the cart (usually a price under MAP)
- Ships from outside the marketplace's country
- Appeared since the last run

These are signs, not proof. Use them to choose which sellers to test-buy from or report.

### Pricing

Pay per ASIN checked: **$0.03 per ASIN** ($0.0285 Bronze, $0.027 Silver, $0.024 Gold and up), plus Apify's tiny start fee. The price is the same whether a listing has 2 offers or 200.

**Free:** ASINs that are not found, listings with no offers, invalid inputs, duplicates and checks Amazon did not answer. You never pay for an empty result.

| Job | ASIN checks | Cost |
|---|---|---|
| The prefilled example | 2 | $0.06 |
| One brand's top products | 20 | $0.60 |
| A client catalog audit | 500 | $15 |
| 50 ASINs every day for a month | 1,500 | $45 |

Set a maximum cost per run in the run options and the Actor stops cleanly when it is reached: you get every row you paid for and nothing you did not.

### Speed and reliability (our tests, 13 October 2026)

- 300 US ASINs in one run: 260 seconds, every ASIN answered (294 with offers, 6 with none, both correct).
- 100 US ASINs: 88 seconds. 2 ASINs (the prefill): about 6 seconds.
- 30 UK ASINs in 26 seconds, 30 German ASINs in 24 seconds, 20 each for France, Italy, Spain, Canada and Australia in 9 to 42 seconds.
- More than 50 test runs, every one succeeded. When Amazon refuses a request the Actor retries it from a new address, so you get an answer instead of a gap.
- 10 ASINs were checked by hand against the offer panel in a browser set to the same US location: every Buy Box winner, price and seller matched.

### Use with AI agents (MCP)

Connect Claude, Cursor or any MCP client to Apify's MCP server at `https://mcp.apify.com` and ask, for example:

> Find unauthorized sellers on my Amazon ASINs B0D5CLSMFB and B0CZ9M6X8Q. My brand is Anker.

The agent searches the Store (for example "Amazon offers" or "amazon hijacker"), finds this Actor, and runs it with:

```json
{ "asins": ["B0D5CLSMFB", "B0CZ9M6X8Q"], "myBrand": "Anker" }
```

The verdict field is written for an agent to quote back directly. `urls`, `startUrls` and `queries` are accepted as aliases of `asins`.

### API

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("vant47/amazon-offers-hijackers").call(run_input={
    "asins": ["B0D5CLSMFB", "B0CZ9M6X8Q"],
    "myBrand": "Anker",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["verdict"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('vant47/amazon-offers-hijackers').call({
    asins: ['B0D5CLSMFB', 'B0CZ9M6X8Q'],
    myBrand: 'Anker',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((row) => console.log(row.verdict));
```

curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/vant47~amazon-offers-hijackers/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"asins": ["B0D5CLSMFB"], "myBrand": "Anker"}'
```

### Integrations

- **Schedules:** run daily or hourly from Apify's scheduler; the history storage turns each run into a change report.
- **Alerts:** send rows where `alert` is true to Slack, email or a webhook through Make, Zapier, n8n or Apify's own integrations.
- **Sheets:** export OFFERS.csv or the dataset to Google Sheets after every run.

### Marketplaces

amazon.com (US), amazon.co.uk (UK), amazon.de (DE), amazon.fr (FR), amazon.it (IT), amazon.es (ES), amazon.ca (CA) and amazon.com.au (AU). Each store is read from an address in its own country, so you see the offers a local shopper sees. Prices are in the store's currency.

### Limits

- It reads what a signed-out shopper sees at one delivery location per country. A few offers that only ship to some regions can be missing; Business-only prices are not shown.
- `maxOffersPerAsin` (default 100) caps very crowded listings; books and collectibles can have hundreds of offers.
- Seller business names and addresses from seller profile pages are not collected.
- Counterfeit-risk signs are hints from public data, not a judgement about any seller.
- Amazon changes its pages from time to time. If a field ever comes back empty, report it in the Issues tab.

### FAQ

**Do I need an Amazon seller account or Brand Registry?** No. It reads the public offer list.

**How do I find my seller ID?** Open your storefront on Amazon; the link contains `seller=A...`. Copy that part into `mySellerIds`.

**What is a hijacker?** A seller who joins your listing and sells the same ASIN, often cheaper, sometimes with fakes. Here every seller that is not you, your approved resellers or Amazon is reported as unauthorized.

**Why does the verdict say "Buy Box suppressed"?** Amazon shows no featured offer for the listing, which usually means a pricing or listing problem worth fixing fast.

**Does it work for used items?** Set `condition` to `all`. Used sellers are listed but are not given counterfeit-risk signs.

**Will the first run show "new sellers"?** No. The first run records a baseline; changes are reported from the second run on.

**How do I keep two clients apart?** Give each its own `historyStoreName`.

### Related searches

Amazon offers scraper, Amazon hijacker alerts, Amazon unauthorized sellers, Amazon seller monitoring, Amazon Buy Box monitor, Amazon MAP violations, Amazon brand protection, Amazon offer listing, Amazon sellers per ASIN.

# Actor input Schema

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

The products to check: ASINs like B0BSHF7WHW or product links like https://www.amazon.com/dp/B0BSHF7WHW. Links from amazon.co.uk, .de, .fr, .it, .es, .ca or .com.au are checked on that marketplace. One result row per ASIN; duplicates are checked once and invalid entries are skipped for free.

## `myBrand` (type: `string`):

Your brand, e.g. Anker or CeraVe. Sellers whose store name contains it (AnkerDirect, Anker Official) count as authorized; everyone else is flagged unauthorized. Several brands: separate them with commas. Leave empty if you only use seller IDs below.

## `mySellerIds` (type: `array`):

Seller IDs (A2L12OQTUXM45G, the seller= part of a store link) or exact store names of you and your approved resellers. Every other seller on your ASINs is reported as unauthorized. With neither a brand nor sellers, the run still lists every seller, the Buy Box and counterfeit-risk signs, but cannot say who is unauthorized.

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

Amazon store for plain ASINs. Product links use their own store.

## `mapPrice` (type: `number`):

Minimum advertised price for every ASIN in this run, e.g. 24.99. Offers under it are flagged and the verdict compares the cheapest unauthorized offer with it. Without it, the comparison uses your own lowest offer, else the Buy Box price.

## `mapPrices` (type: `object`):

A different MAP for each ASIN, e.g. {"B0BSHF7WHW": 24.99, "B07PGL2ZSL": 12.5}. Overrides the single MAP above.

## `condition` (type: `string`):

New offers only (where hijackers sell) or all offers including used and renewed.

## `trackChanges` (type: `boolean`):

Remember the sellers of each ASIN in a named storage in your account, so the next run reports new sellers, sellers that left and Buy Box changes. Schedule the Actor daily and it becomes a hijacker alert feed.

## `historyStoreName` (type: `string`):

Name of the key-value store that keeps the seller history. Use a different name per brand or client to keep their histories apart.

## `maxOffersPerAsin` (type: `integer`):

Most listings have under 30 offers. The price per ASIN is the same however many offers it has.

## `amazonIsAuthorized` (type: `boolean`):

Treat offers sold by Amazon (Amazon.com, Amazon EU, Amazon Resale) as authorized, as for most brands that sell to Amazon as a vendor.

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

Same as the ASINs field, for agents that pass links: https://www.amazon.com/dp/B0BSHF7WHW.

## Actor input object example

```json
{
  "asins": [
    "B0D5CLSMFB",
    "B0CZ9M6X8Q"
  ],
  "myBrand": "Anker",
  "marketplace": "US",
  "condition": "new",
  "trackChanges": true,
  "historyStoreName": "amazon-offers-history",
  "maxOffersPerAsin": 100,
  "amazonIsAuthorized": true
}
```

# Actor output Schema

## `verdicts` (type: `string`):

No description

## `report` (type: `string`):

No description

## `offers` (type: `string`):

No description

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

No description

## `all` (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": [
        "B0D5CLSMFB",
        "B0CZ9M6X8Q"
    ],
    "myBrand": "Anker"
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/amazon-offers-hijackers").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": [
        "B0D5CLSMFB",
        "B0CZ9M6X8Q",
    ],
    "myBrand": "Anker",
}

# Run the Actor and wait for it to finish
run = client.actor("vant47/amazon-offers-hijackers").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": [
    "B0D5CLSMFB",
    "B0CZ9M6X8Q"
  ],
  "myBrand": "Anker"
}' |
apify call vant47/amazon-offers-hijackers --silent --output-dataset

```

## MCP server setup

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

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/fdBU5tUBRsETE6RQT/builds/CZR0nDReCzzLFZwOq/openapi.json