mcp-price-tracker

MCP server for price tracking, a price tracker and price drop watcher for shop pages. Check and watch product prices on ordinary shop pages.

Works with Claude Desktop, Claude Code, Cursor and any Model Context Protocol client. Runs on your own machine, or hosted with no install.

Product page: https://mcp.zovo.one/s/price-tracker — what it does, the tools it exposes, and a live token endpoint.

Install

Hosted, nothing to install. Get a token from https://mcp.zovo.one/mcp/connect (the connect page) or https://mcp.zovo.one/mcp/token (the same token as JSON); a free anonymous one is issued on the spot and a Pro key works the same way. Then point an MCP client at https://mcp.zovo.one/mcp/price-tracker over streamable-http and send the token as Authorization: Bearer <token>.

If your client cannot set headers, put the token in the path instead: https://mcp.zovo.one/mcp/price-tracker/t/<token>. Both forms work. The bare URL with no token answers 401 on tools/call, so the token is not optional.

Claude Desktop, one click. Download price-tracker.mcpb from the latest release and double-click it.

From source. The mirror is self-contained: every @theluckystrike/* dependency is vendored, so a fresh clone builds with no extra setup.

git clone https://github.com/theluckystrike/mcp-price-tracker.git
cd mcp-price-tracker
npm install && npm run build

Then point your client at the built entry point:

{
  "mcpServers": {
    "price-tracker": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-price-tracker/dist/index.js"]
    }
  }
}

@theluckystrike/mcp-price-tracker is not published on npm yet, so an npx -y @theluckystrike/mcp-price-tracker command will fail. The three paths above are the working ones and each is exercised by CI.

Read-only mirror of mcp-servers/servers/price-tracker. See MIRROR.md.

Featured on Awesome MCP Servers — directory listing | live hosted endpoint, free tier, no signup.

Ask your assistant what something costs right now. Point it at any product page and it reads the price off the page, remembers it, and tells you next time whether the price moved, how far, and whether it reached the number you were waiting for. It works on ordinary shop pages by reading the structured data most stores already publish (JSON-LD, Open Graph, microdata) and falling back to the visible price when they do not. When a large retailer blocks automated requests it says so plainly and lets you record the price yourself so the history stays intact. Everything is stored in a JSON file on your own machine.

Built by theluckystrike.

In the official MCP Registry (io.github.theluckystrike/price-tracker-drop-alert-watch).

Watch any product page for price drops from chat, no scraping service, no account, all local.

60-second install

npm publish for @theluckystrike/mcp-price-tracker is pending. Until then, the .mcpb one-click bundle or a clone+build is the working path, both are verified below.

One-click (.mcpb): download price-tracker.mcpb from the latest release and double-click it in Claude Desktop: https://github.com/theluckystrike/mcp-servers/releases/latest

(claude_desktop_config.json):

{
  "mcpServers": {
    "price-tracker": {
      "command": "npx",
      "args": ["-y", "@theluckystrike/mcp-price-tracker"]
    }
  }
}

Claude Code:

claude mcp add price-tracker -- npx -y @theluckystrike/mcp-price-tracker

(.cursor/mcp.json):

{
  "mcpServers": {
    "price-tracker": {
      "command": "npx",
      "args": ["-y", "@theluckystrike/mcp-price-tracker"]
    }
  }
}

The npx form above starts working the moment the package is published. Until then, use the .mcpb bundle above, or build from source with exactly these three commands:

git clone https://github.com/theluckystrike/mcp-servers.git && cd mcp-servers
npm install
npm run build -w packages/mcp-license -w servers/price-tracker

Then point your client's command at node with one arg: the absolute path to servers/price-tracker/dist/index.js.

To run in Pro mode set MCP_LICENSE_KEY in the same config block, or call license_activate once with your key.

Tools

Resource: prices://watches - JSON of every watch with its latest price.

Prompt: check_prices - refreshes every watch and summarises the drops and target hits in one command.

What you can say

Worked example

A real run against books.toscrape.com, from docs/USER_VALUE_R2.md, with WebFetch/WebSearch disallowed so the price-tracker's own tools had to answer:

You: What does this cost right now: https://books.toscrape.com/catalogue/...?

  price_check { url: "https://books.toscrape.com/catalogue/..." }
  -> price 51.77, currency GBP, source regex-fallback, confidence low

Assistant: GBP 51.77. Confidence: low (regex-fallback) -- this page has no
structured price data, so I read it from the visible text.

The confidence label is not decoration: books.toscrape.com carries no JSON-LD or microdata, so this is the one case in testing where the regex fallback was the only path to a number, and the model relayed the "low" label to the user unprompted rather than stating 51.77 as a fact.

Alerts: nothing runs in the background

There is no scheduler and no daemon. A watch is a stored history, not a subscription: prices are re-read only when watch_refresh runs, and alerts_pending reports on what is already stored. The working pattern is to say "refresh my watches" at the start of a session (or run the check_prices prompt), then ask what dropped.

Free vs Pro

Get Pro - $19 for this server, $39 for every server, lifetime.

How prices are read

In order: JSON-LD Product/Offer (price, priceCurrency, lowPrice), microdata itemprop="price", Open Graph og:price:amount / product:price:amount, meta itemprop, data-price attributes, common price class and id hints (including Amazon's a-offscreen), and finally a regex over the visible text of the first 200 KB. European and US separators are both understood, so 1.299,00 EUR and 1,299.00 USD both become 1299.00.

Prices are stored as decimal strings in the major unit with a . decimal separator and no grouping, for example "1299.00". Timestamps are ISO 8601 UTC.

Every reading carries a confidence: high for JSON-LD, microdata, meta itemprop and Open Graph; medium for data-price attributes and price class or id hints; low for the regex fallback. A low reading on a page with no product title is reported but never stored.

Where a page describes several products in JSON-LD (recommendations, "customers also bought"), the offers of one product are never pooled with another's: the product whose name matches the page title wins, otherwise the first product carrying offers. Crossed-out and previous prices (<s>, <del>, <strike>, and classes such as old-price, was, compare-at-price, list-price, rrp) are skipped, so a struck 199 next to a live 99 reports 99. An ISO code written next to the number ("$10 USD") wins over the currency guessed from the domain, and twitter:data1 - free text such as "Free shipping over $50" - is not read as a price.

Pages are fetched with a desktop browser User-Agent, a 12 second timeout, redirects followed, and a 2 MB body cap. After the fetch the final URL is compared with the one you asked for: if the shop redirected off the product path - a different path depth, a category or home page, or a generic title such as "Products", "Home", the shop name alone, or "not found" - you get the shop redirected to <finalUrl>, which is not a product page instead of the cheapest item on the listing it landed on. A redirect that only inserts a canonical slug in front of the same product id or path (Newegg, Amazon /dp/, Zalando-style URLs) is accepted, not refused.

How it stores data

Watches and their price history live in one JSON file: ${XDG_DATA_HOME:-~/.local/share}/mcp-servers/price-tracker/watches.json. Every mutation (watch_add, watch_remove, watch_refresh, price_add_manual) happens under an advisory lock file, .../price-tracker/.lock, held across the load-mutate-save cycle so two refreshes running at once cannot interleave. price_check and read-only tools do not need the lock. Saves write to a temporary file and rename it into place, so an interrupted write cannot leave a half-written file. To back up your watch history, copy watches.json.

Only a missing file counts as "no watches yet". If watches.json exists but cannot be read or parsed, the server never treats it as empty: the unreadable bytes are moved to watches.json.corrupt-<timestamp>, the fault is written to stderr, and every tool answers with an error naming that file until the server is restarted. A damaged database can therefore never be silently overwritten by the next price you record.

Limits and honest caveats

• Real-world extraction success is roughly 5 of 12 on a mixed sample of major retailers: five sites returned an outright bot-wall 403 (H&M, Allegro, MediaMarkt, Home Depot, Etsy), one timed out (Best Buy), and the rest split between correct prices and one intentionally refused reading (a redirect off the product page). This is a property of the open web, not a bug the server can fix, there is no headless browser or CAPTCHA solver here, by design (no native deps, no paid API). price_add_manual is the working answer for a blocked shop.
• There is no background job. Nothing checks prices unless you (or your client, via a scheduled script you run yourself) call watch_refresh. This is not a missing feature; a local stdio server has no business running a daemon on your machine.
• Free tier caps watches at 3 and history at the last 30 observations per watch; price_check and alerts_pending are unlimited on free.
• A low-confidence regex reading is still reported, but never silently treated as certain, pass it on to the user as an estimate, not a fact.

Troubleshooting

• npx hangs or fails to find the package: npm publish for this package is pending. Use the .mcpb bundle or the clone-and-build path above until it lands.
• Using the .mcpb bundle: it installs into Claude Desktop directly; there is no separate config step.
• Using the clone path: the server binary is servers/price-tracker/dist/index.js after npm run build. Point your client's command at node with that absolute path as the only argument.
• Node version: requires Node >= 18. Check with node -v.
• A watch always errors "not a product page": the shop redirected you off the URL you gave it (a category page, home page, or a generic title). Fetch the exact product URL again from the shop and re-add the watch, or use price_add_manual if the shop keeps redirecting.
• A shop returns 403 every time: it is blocking automated requests. This is expected for a subset of large retailers (see Limits above); use price_add_manual.
• Nothing shows up / silent failures: logs go to stderr only, never stdout. In Claude Desktop check Settings -> Developer -> the server's log file; in Claude Code check the terminal or --mcp-debug.

Privacy

All data stays local, in ${XDG_DATA_HOME:-~/.local/share}/mcp-servers/price-tracker/watches.json. The only network requests are to the product pages you name. License keys verify offline; nothing is sent anywhere.

Pairs with

• mcp-invoice, bill a client for something you bought after tracking its price.
• mcp-spreadsheet, export price_history and analyze it as a sheet.
• mcp-time-tracker, track the hours you spend shopping around, if that is somehow billable.
• office-suite, every sibling server behind one install, one config entry.
• Guide: Watch a product price with Claude and get told when it drops

FAQ

There is no scheduler in this server. Prices are only re-read when watch_refresh runs, which happens when you ask for it (or when a cron/launchd job you set up yourself calls it).

Either the shop returned a bot-wall response (403) or the request redirected off the product page onto a listing, category or home page. Both are reported honestly instead of returning a wrong number; use price_add_manual to keep the history going by hand.

The price came from a text-pattern fallback rather than the page's own structured data (JSON-LD, microdata, Open Graph). It is usually right but has not been verified against a machine-readable field.

watch_add and price_add_manual accept an explicit currency, but the number you store should match what you actually read, the server does not convert currencies.

No. The only outbound requests are to the product URLs you add, to fetch their pages. There is no telemetry and no account.

MIT licensed.

Use these docs as an MCP server

Any MCP client (Claude, Cursor, Windsurf, VS Code) can read this repository's documentation directly via GitMCP — no install:

• Docs MCP URL: https://gitmcp.io/theluckystrike/mcp-price-tracker