# Competitor Price Tracker & Price Comparison by Product URL (`fayoussef/competitor-price-tracker-price-comparison-by-product-url`) Actor

Paste any product URL to get every retailer selling the same item, live prices, your market rank, and a suggested pricing action. Matches are strictly verified by UPC, EAN, GTIN, and MPN, with no fuzzy titles or foreign currency guesses. Works on Amazon, Walmart, Target, Best Buy, eBay, and Shopify.

- **URL**: https://apify.com/fayoussef/competitor-price-tracker-price-comparison-by-product-url.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Competitor Price Tracker: Compare Any Product URL Across Every Retailer

**Paste one product URL. Get every other store selling the same item, their live price, your rank in the market, and what to do about it.**

This competitor price tracker turns a single product link into a full price comparison. It searches the web for the same item, verifies each match by UPC, EAN, GTIN and MPN (not fuzzy title guessing), extracts the live price from every competitor page, and returns one clean row per retailer with your market position and a suggested pricing action.

Built for ecommerce sellers, repricing teams, brand managers enforcing MAP policy, dropshippers, and AI agents that need grounded, real-time pricing data.

Works with **Amazon, Walmart, Target, Best Buy, eBay, Fnac, Newegg, B\&H, Shopify, WooCommerce, BigCommerce, Magento** and any independent online store.

### Why use this instead of a Google Shopping scraper

| | This competitor price tracker | Typical price comparison scraper |
|---|---|---|
| Input | Any product URL you already have | Keyword or search term |
| Matching | UPC / EAN / GTIN / MPN plus AI confirmation | Fuzzy title similarity |
| Wrong-variant results | Rejected, with the reason recorded | Common |
| Foreign currency prices | Dropped, never silently converted | Mixed into the same column |
| Output | One row per verified competitor, with your rank | A flat list of offers |
| Interrupted runs | Resume where they stopped | Start over |

Title matching is the reason most price comparison tools return the 128 GB model when you asked about the 256 GB one. This Actor confirms the identifier before it counts a competitor.

### What you get

One row per `(reference product, matched competitor)`. The reference identity and market aggregates repeat on every row, so every column stays sortable and filterable in Excel, Google Sheets, or your database.

**Your product (the reference)**

| Field | What it holds |
|---|---|
| `reference_url` | The product URL you supplied |
| `reference_title` | Product name read from your page |
| `reference_brand` | Brand extracted from the page |
| `reference_model` | Model or variant name |
| `reference_identifiers` | JSON of the UPC / EAN / GTIN / MPN codes found |
| `reference_price` | Your current price |
| `reference_currency` | ISO-4217 currency code |
| `reference_availability` | In-stock status |

**Your market position**

| Field | What it holds |
|---|---|
| `matches_found` | Confirmed competitor matches for this product |
| `urls_checked` | Search results fetched and classified |
| `min_comp_price` / `avg_comp_price` / `max_comp_price` | The competitor price distribution |
| `your_rank` | Your position from cheapest to most expensive |
| `price_position` | Cheapest in market / Below market avg / Above market avg / Most expensive |
| `pct_vs_avg_market` | Signed percentage difference against the market average |
| `pct_vs_cheapest` | Signed percentage difference against the cheapest competitor |
| `suggested_action` | Plain-English pricing move, e.g. "Room to raise price toward avg" |

**Each competitor**

| Field | What it holds |
|---|---|
| `competitor_domain` | Retailer domain |
| `competitor_url` | Direct link to the competitor listing |
| `competitor_product_name` | Title on the competitor page |
| `comp_price` / `comp_currency` | Competitor price |
| `comp_vs_you_abs` | Price difference against you, absolute |
| `comp_vs_you_pct` | Price difference against you, percent |
| `market_rank` | This competitor's rank, where 1 is cheapest |
| `confidence` | Match confidence: high, medium or low |
| `shipping_rules` | Shipping terms found on the page |
| `reasoning` | Why this URL was confirmed as the same product |
| `is_cheapest` | True if this is the cheapest confirmed match |
| `status` | `OK`, `No matches`, or the error string |

### Sample output

```json
{
  "reference_url": "https://www.amazon.com/dp/B08N5WRWNW",
  "reference_title": "Echo Dot (4th Gen) Smart Speaker with Alexa",
  "reference_brand": "Amazon",
  "reference_model": "Echo Dot 4th Gen",
  "reference_identifiers": "{\"UPC\": \"840268945237\", \"MPN\": \"B08N5WRWNW\"}",
  "reference_price": 49.99,
  "reference_currency": "USD",
  "reference_availability": "In Stock",
  "matches_found": 4,
  "urls_checked": 18,
  "min_comp_price": 44.95,
  "avg_comp_price": 51.20,
  "max_comp_price": 59.99,
  "your_rank": 2,
  "price_position": "Below market avg",
  "pct_vs_avg_market": -2.36,
  "pct_vs_cheapest": 11.21,
  "suggested_action": "Room to raise price toward avg",
  "competitor_domain": "walmart.com",
  "competitor_url": "https://www.walmart.com/ip/Echo-Dot-4th-Gen/586352757",
  "competitor_product_name": "Amazon Echo Dot (4th Gen) Smart Speaker",
  "comp_price": 44.95,
  "comp_currency": "USD",
  "comp_vs_you_abs": -5.04,
  "comp_vs_you_pct": -10.08,
  "market_rank": 1,
  "confidence": "high",
  "shipping_rules": "Free shipping over $35",
  "reasoning": "Same brand, model, and UPC 840268945237 confirmed on page.",
  "is_cheapest": true,
  "status": "OK"
}
```

### Who uses it

- **Ecommerce sellers** tracking competitor prices on Amazon and Walmart for their own SKUs
- **Repricing teams** catching any retailer that undercuts their floor price
- **Brand managers** enforcing MAP policy and spotting unauthorized resellers
- **Dropshippers and arbitrage buyers** finding the cheapest supplier for a product
- **Market researchers** capturing the full price distribution, not just the first three results
- **AI agents** answering "what is the cheapest price online for X" with fresh, grounded data

### How it works

1. **Input:** one or more product URLs, for example `https://www.amazon.com/dp/B08N5WRWNW`. Each product runs in parallel.
2. **Extract:** structured data (JSON-LD, microdata, Open Graph) is read first, so brand, model, price and identifiers come from the page itself rather than a guess.
3. **Search:** a geo-targeted Google search per product, optionally narrowed to your `includedDomains` and filtered against a social and review-site blocklist.
4. **Pre-filter:** an AI pass drops obviously irrelevant results before any page is fetched, which is what keeps the run cheap.
5. **Verify:** surviving pages are fetched and classified. A competitor counts only when brand, model and identifier line up.
6. **Score:** min, average and max, your rank, percentage gaps, and a suggested action.
7. **Output:** one row per confirmed competitor, streamed live to the dataset and exportable as JSON, CSV, Excel or XML.

Runs are resumable: if a run is interrupted or migrated, re-running the same input picks up where it stopped instead of paying to redo finished work.

### Scraper API key: read this before your first run

Without a Scraper API key, the tracker fetches pages through residential proxy only. That works for small and mid-size shops, but Amazon, Walmart, Target, Best Buy, Fnac and eBay reliably block it, and you will get empty results for exactly the retailers you care about most.

Get a free key with 1,000 credits per month here: **https://scrape.do/?fpr=automationbyexperts**

Sign up, copy the token, and paste it into the `scrapedoApiKey` input field.

### Input example

```json
{
  "productUrls": [
    { "url": "https://www.amazon.com/dp/B08N5WRWNW" }
  ],
  "scrapedoApiKey": "YOUR_SCRAPEDO_TOKEN",
  "country": "us",
  "currency": "USD",
  "maxCompetitors": 10,
  "maxPages": 2
}
```

Leave `includedDomains` empty to search the whole web, or fill it to compare against a fixed list of retailers only.

### Cost and free tier

Free Apify accounts are capped at 1 product URL, 1 search page, and 3 competitors per product, which is enough to see the output shape before committing. Paid accounts get whatever you put in the input. Upgrade at [Apify pricing](https://apify.com/pricing?fpr=youssef).

The AI model that confirms matches is billed separately through Apify's model integration, or directly by OpenRouter if you supply your own key. The model dropdown shows each model's real price per million tokens, and the default is a cheap, fast one that is accurate enough for match confirmation.

### Frequently asked questions

**How does a competitor price tracker verify it found the same product?**
It reads UPC, EAN, GTIN and MPN identifiers from structured data on both pages, then has an AI model confirm brand, model and variant. A candidate that fails either check is rejected, and the `reasoning` field records why.

**How does it get past anti-bot protection?**
Residential proxies for general stores, and the scrape.do API for Amazon, Walmart, Target, Best Buy, eBay and Cloudflare-protected sites.

**Are the prices live or cached?**
Live. Every run fetches each competitor page in real time.

**What output formats are supported?**
JSON, CSV, Excel and XML, from the dataset tab or the Apify API.

**Does it work outside the United States?**
Yes. Set `country` to any ISO code such as `gb`, `de`, `fr`, `ca`, `au`, `jp` or `in`. Both the Google geo-targeting and the residential proxy country follow it.

**What happens to prices in another currency?**
They are dropped, not converted. A price comparison built on a guessed exchange rate is worse than no price at all, so every number you get back is already in your target currency.

**Can I restrict which retailers it checks?**
Yes. Use `includedDomains` to whitelist specific stores, or `excludedDomains` to skip ones that waste retries.

**Can I track my own Shopify or WooCommerce store?**
Yes. Any public product URL works as the reference input.

**Can I monitor prices on a schedule?**
Yes. Use Apify Schedules for hourly or daily runs, and webhooks to push price changes into Slack, Google Sheets, or your own database.

**Can I call it from an AI agent?**
Yes, over the REST API or as an MCP server. See the next section.

### Use via API or MCP

Run the price monitor from any backend through the Apify REST API:

```
POST https://api.apify.com/v2/acts/fayoussef~competitor-price-tracker-compare-any-product-url/runs?token=YOUR_TOKEN
```

Or wire it into an AI agent (Claude, ChatGPT, Cursor) as an MCP server for grounded, real-time price answers:

```
https://mcp.apify.com/actors/fayoussef~competitor-price-tracker-compare-any-product-url
```

### Need a custom scraper?

Need different fields, a specific site, or a fully managed price-monitoring pipeline? Visit [automationbyexperts](https://scrape.do/?fpr=automationbyexperts).

***

**Related searches:** competitor price tracker, competitor price monitoring software, price comparison tool, price intelligence API, Amazon price tracker, Walmart price tracker, Target price tracker, Best Buy price tracker, eBay price scraper, Shopify price monitor, MAP monitoring tool, repricing tool, dropshipping product research, ecommerce market positioning, UPC EAN GTIN product matching, find who else sells my product.

# Actor input Schema

## `productUrls` (type: `array`):

Reference product URLs to track. Use canonical product pages (e.g. /dp/B0XXXXX), not /offer-listing/ pages. Each URL is processed in parallel.

## `country` (type: `string`):

ISO-3166 country code. Controls Google SERP geo-targeting AND residential proxy country for page fetches.

## `currency` (type: `string`):

ISO-4217 currency code (e.g. USD, EUR, GBP). Competitor prices in any other currency are dropped (not converted) so all reported prices are comparable.

## `maxCompetitors` (type: `integer`):

Stop searching once this many confirmed matches are found per product.

## `maxPages` (type: `integer`):

Number of Google search result pages to scan for each product. Each page yields ~10 candidate URLs.

## `excludedDomains` (type: `array`):

Domains to skip when scanning competitors (in addition to the built-in social/review/hard-blocked list).

## `includedDomains` (type: `array`):

If provided, the Google search query is restricted to these domains via `site:` operators (e.g. amazon.com, walmart.com). Leave empty to search the whole web.

## `model` (type: `string`):

The AI model used to confirm product matches. The list is the live model catalog, ordered by popularity, with each model's real price per million tokens. The default is a cheap, fast model that is accurate enough for match confirmation: pick a bigger one only if you scrape pages where matching is genuinely hard. Need a model that is not listed? Fill in `customModel` below, which overrides this selection.

## `customModel` (type: `string`):

Any OpenRouter-compatible model ID (e.g. `openai/o1-mini`, `x-ai/grok-2`, `cohere/command-r-plus`). If set, this overrides the `AI model` selection above. Browse the full catalog at https://openrouter.ai/models.

## `scrapedoApiKey` (type: `string`):

**Strongly recommended, and required if you want most sites (Amazon, eBay, Walmart, Cloudflare-protected stores, etc.) to actually be scraped.** Without this key the actor only uses curl\_cffi + residential proxy, which is blocked by most major retailers and will return empty results for them.

Get a **free** key with 1000 credits/month using my referral link: https://scrape.do/?fpr=automationbyexperts (sign up, copy your token, paste it here).

Domains listed in `src/scrapedo_direct_domains.txt` (Amazon, eBay by default) skip curl\_cffi entirely and go straight through this API to save retry cycles.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
    },
    {
      "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ],
  "country": "us",
  "currency": "USD",
  "maxCompetitors": 10,
  "maxPages": 2,
  "excludedDomains": [],
  "includedDomains": [],
  "model": "meta-llama/llama-3.1-8b-instruct"
}
```

# Actor output Schema

## `priceIntelligence` (type: `string`):

All competitor matches across all input products. One row per (product, competitor); reference + market aggregate fields repeat per row for filtering/sorting.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.amazon.com/dp/B09B8V1LZ3"
        },
        {
            "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
        },
        {
            "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/competitor-price-tracker-price-comparison-by-product-url").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 = { "productUrls": [
        { "url": "https://www.amazon.com/dp/B09B8V1LZ3" },
        { "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121" },
        { "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/competitor-price-tracker-price-comparison-by-product-url").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B09B8V1LZ3"
    },
    {
      "url": "https://www.walmart.com/ip/AirPods-Pro-2nd-generation-with-MagSafe-Case-USB-C/5689919121"
    },
    {
      "url": "https://www.target.com/p/airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ]
}' |
apify call fayoussef/competitor-price-tracker-price-comparison-by-product-url --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/competitor-price-tracker-price-comparison-by-product-url",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Xz0mhlqNDExhGoNAL/builds/0OLjz5yetcoW7ZRwc/openapi.json