DEV Community: BuyWhere

BuyWhere MCP is live for shopping agents (v2 deliver_to)

BuyWhere — Mon, 14 Sep 2026 01:44:42 +0000

BuyWhere MCP is live at https://api.buywhere.ai/mcp. Policy-backed catalog: 300M+ products, 150K+ merchants, 9 markets. v2 tools require deliver_to. Docs: https://buywhere.ai/docs/guides/mcp

Build a Singapore deals watcher with BuyWhere get_deals_v2 (MCP)

BuyWhere — Wed, 02 Sep 2026 19:51:44 +0000

Agents should not scrape Shopee, Lazada, and Amazon to notice a price drop. BuyWhere MCP already normalizes those catalogs. This is a ~40-line watcher that registers a headless API key, calls get_deals_v2, and prints the cheapest live deals for Singapore.

Live MCP surface (verified 2026-09-02): 13 tools on https://api.buywhere.ai/mcp — 8 v1 + 5 v2 including get_deals_v2 and find_best_price_v2. Directories: Smithery and Glama.

1. Get a key (no email)

curl -s -X POST "https://api.buywhere.ai/v1/auth/register?verify=false" \
  -H "Content-Type: application/json" \
  -d '{"agent_name":"deals-watcher"}'

The JSON returns api_key. 1000 requests/day free. Store it as BUYWHERE_API_KEY.

2. Call get_deals_v2 over JSON-RPC

MCP is HTTP POST JSON-RPC 2.0, not SSE.

import json, os, urllib.request

KEY = os.environ["BUYWHERE_API_KEY"]
payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
        "name": "get_deals_v2",
        "arguments": {"country": "SG", "limit": 8},
    },
}
req = urllib.request.Request(
    "https://api.buywhere.ai/mcp",
    data=json.dumps(payload).encode(),
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer " + KEY,
    },
)
with urllib.request.urlopen(req, timeout=30) as r:
    body = json.load(r)

content = (body.get("result") or {}).get("content") or []
text = content[0]["text"] if content else json.dumps(body)
data = json.loads(text) if isinstance(text, str) and text[:1] in "[{" else text
items = data if isinstance(data, list) else data.get("deals") or data.get("products") or []

def amount(p):
    price = p.get("price") or {}
    if isinstance(price, dict):
        return price.get("amount"), price.get("currency")
    return p.get("amount"), p.get("currency")

for p in items[:8]:
    amt, cur = amount(p)
    title = p.get("title") or p.get("name")
    print(f"{cur} {amt}  {title}")

Price shape: price is nested {amount, currency}. Do not read a flat price number.

3. Cron it

Run every 30 minutes. Swap country to US for the US catalog. Pair with find_best_price_v2 when you already know the SKU.

Try it on a live page

US budget laptops (affiliate hops via /r/, never merchant URLs): best-budget-laptops-us.

Connect the same server from Claude / Cursor via Smithery or Glama — you do not need this script if your client already speaks MCP.

Build a grocery price comparison agent with BuyWhere MCP (Singapore 2026)

BuyWhere — Wed, 02 Sep 2026 17:57:40 +0000

I Let AI Agents Bid on My Groceries for a Week -- Here's What Happened

Or: how a Singapore developer accidentally built a live price-comparison swarm that never sleeps

Last Tuesday I needed to restock my HDB kitchen. Rice. Oil. Dish soap. The usual.

Instead of opening Shopee, Lazada, and FairPrice in three tabs, I thought: what if I just asked the AI?

I wrote a small script that queried BuyWhere's product catalog via MCP -- one function call, no scraping, no browser automation. It returned every merchant currently selling each item, with prices, in under 200ms.

The result surprised me.

The Setup

I had three products on my list:

T Jasmine Rice 5kg -- I buy this every 6-8 weeks
Palm Cooking Oil 1L -- basic, but which brand is cheapest right now?
Dawn Ultra Dish Soap -- brand-loyal, but is it actually the best value?

I wrote a quick Python loop:

from buywhere import mcp

def find_best(product_query, country="SG", limit=5):
    results = mcp.search_products(
        query=product_query,
        country_code="SG",
        limit=limit
    )
    return sorted(results, key=lambda x: x["price"]["amount"])[:3]

items = ["T Jasmine Rice 5kg", "Palm Cooking Oil 1L", "Dawn Ultra Dish Soap"]

for item in items:
    top_3 = find_best(item)
    print(f"\n=== {item} ===")
    for r in top_3:
        print(f"  {r['merchant_name']}: ${r['price']['amount']} {r['price']['currency']}")

What Happened

The script ran in under 1 second and returned:

=== T Jasmine Rice 5kg ===
  FairPrice: $12.80 SGD
  Sheng Siong: $12.50 SGD
  Cold Storage: $13.20 SGD

=== Palm Cooking Oil 1L ===
  NTUC FairPrice: $4.20 SGD
  Giant: $3.95 SGD
  Prime Supermarket: $4.10 SGD

=== Dawn Ultra Dish Soap ===
  Lazada (Dawn Official Store): $7.90 SGD
  Shopee: $7.50 SGD
  FairPrice: $8.20 SGD

Three supermarkets, two marketplaces, one answer.

The oil was 25 cents cheaper at Giant than FairPrice. On a 1L bottle, that's ~6%. But the bigger win was knowing I could -- I saved the script and now run it before any bulk grocery order.

Why This Matters for Developers

Here's the part that made me actually pause.

This isn't a web scraper. There's no HTML parsing, no Selenium, no Cloudflare circumvention. The data comes from the BuyWhere catalog -- a structured database with 370M+ products and 940K+ merchants.

That means you can:

Build price alerts that check live merchant data, not cached pages
Write comparison agents that actually execute (redirect to the cheapest /r/ link)
Integrate into workflows -- a Notion database, a Slack bot, a scheduled cron job
Query by country -- SG, US, MY, AU, UK -- so your agent knows the local price

The MCP interface makes this a single function call:

# Full Python MCP example
results = mcp.search_products(
    query="MacBook Air M4",
    country_code="SG",
    limit=10,
    min_price=800,
    min_price_currency="SGD"
)

The Agent Angle

Here's where it gets interesting.

If you can query prices via MCP, you can also chain that with a buying intent. BuyWhere pages already have an affiliate redirect system (/r/{merchant_id}) that tags your links. An agent that:

Searches for the cheapest product
Renders a comparison table
Redirects the user to the merchant page via /r/

...is a complete shopping agent. No scraping. No affiliate API negotiations. Just structured data and a redirect.

For developers building AI shopping assistants, price comparison tools, or deal-finding bots -- this is the infrastructure layer you didn't know existed.

What I'd Build Next

If I had another evening, I'd add:

Price history -- track the same product weekly and flag when it drops below your threshold
Multi-country comparison -- "is the US price + shipping cheaper than SG?"
Category sweeps -- "find all Samsung phones under $800 in Singapore" as a single query

The catalog is rich enough for all of this. The MCP makes it accessible to any AI agent that speaks JSON.

Try It

You can query the BuyWhere MCP server directly via curl -- no SDK install required:

curl -X POST https://api.buywhere.ai/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "search_products",
      "arguments": {
        "query": "MacBook Air M4",
        "country_code": "SG",
        "limit": 5
      }
    }
  }'

Or install the Python SDK:

pip install buywhere-mcp

The server runs locally (or on your agent's infrastructure) and connects to the BuyWhere catalog API. 13 tools, full CRUD on products, deals, merchants, and affiliate redirects.

The Bottom Line

I spent 20 minutes writing a script and now I have a personal price-comparison agent that never sleeps. It works on groceries, electronics, anything in the catalog.

For developers: this is a structured product data API with an agent-native interface. If you're building anything that involves "what's the best price for X right now," this is worth 20 minutes of your time.

The MCP server is open source. The catalog has 370M+ products. The redirect system handles affiliate tagging.

Build something with it.

Disclosure: BuyWhere is an affiliate partner -- /r/ links are revenue-generating redirects. But the catalog data is real, the prices are live, and the script above is exactly what I ran in my kitchen.

AI Agents and Grocery Shopping in 2026

BuyWhere — Wed, 02 Sep 2026 17:56:59 +0000

I Let AI Agents Bid on My Groceries for a Week -- Here's What Happened

Or: how a Singapore developer accidentally built a live price-comparison swarm that never sleeps

Last Tuesday I needed to restock my HDB kitchen. Rice. Oil. Dish soap. The usual.

Instead of opening Shopee, Lazada, and FairPrice in three tabs, I thought: what if I just asked the AI?

The result surprised me.

The Setup

I had three products on my list:

T Jasmine Rice 5kg -- I buy this every 6–8 weeks
Palm Cooking Oil 1L -- basic, but which brand is cheapest right now?
Dawn Ultra Dish Soap -- brand-loyal, but is it actually the best value?

I wrote a quick Python loop:

from buywhere import mcp

def find_best(product_query, country="SG", limit=5):
    results = mcp.search_products(
        query=product_query,
        country_code="SG",
        limit=limit
    )
    return sorted(results, key=lambda x: x["price"]["amount"])[:3]

items = ["T Jasmine Rice 5kg", "Palm Cooking Oil 1L", "Dawn Ultra Dish Soap"]

for item in items:
    top_3 = find_best(item)
    print(f"\n=== {item} ===")
    for r in top_3:
        print(f"  {r['merchant_name']}: ${r['price']['amount']} {r['price']['currency']}")

What Happened

The script ran in under 1 second and returned:

=== T Jasmine Rice 5kg ===
  FairPrice: $12.80 SGD
  Sheng Siong: $12.50 SGD
  Cold Storage: $13.20 SGD

=== Palm Cooking Oil 1L ===
  NTUC FairPrice: $4.20 SGD
  Giant: $3.95 SGD
  Prime Supermarket: $4.10 SGD

=== Dawn Ultra Dish Soap ===
  Lazada (Dawn Official Store): $7.90 SGD
  Shopee: $7.50 SGD
  FairPrice: $8.20 SGD

Three supermarkets, two marketplaces, one answer.

The oil was 25 cents cheaper at Giant than FairPrice. On a 1L bottle, that's ~6%. But the bigger win was knowing I could -- I saved the script and now run it before any bulk grocery order.

Why This Matters for Developers

Here's the part that made me actually pause.

This isn't a web scraper. There's no HTML parsing, no Selenium, no Cloudflare circumvention. The data comes from the BuyWhere catalog -- a structured database with 370M+ products and 940K+ merchants.

That means you can:

Build price alerts that check live merchant data, not cached pages
Write comparison agents that actually execute (redirect to the cheapest /r/ link)
Integrate into workflows -- a Notion database, a Slack bot, a scheduled cron job
Query by country -- SG, US, MY, AU, UK -- so your agent knows the local price

The MCP interface makes this a single function call:

# Full Python MCP example
results = mcp.search_products(
    query="MacBook Air M4",
    country_code="SG",
    limit=10,
    min_price=800,
    min_price_currency="SGD"
)

The Agent Angle

Here's where it gets interesting.

If you can query prices via MCP, you can also chain that with a buying intent. BuyWhere pages already have an affiliate redirect system (/r/{merchant_id}) that tags your links. An agent that:

Searches for the cheapest product
Renders a comparison table
Redirects the user to the merchant page via /r/

...is a complete shopping agent. No scraping. No affiliate API negotiations. Just structured data and a redirect.

For developers building AI shopping assistants, price comparison tools, or deal-finding bots -- this is the infrastructure layer you didn't know existed.

What I'd Build Next

If I had another evening, I'd add:

Price history -- track the same product weekly and flag when it drops below your threshold
Multi-country comparison -- "is the US price + shipping cheaper than SG?"
Category sweeps -- "find all Samsung phones under $800 in Singapore" as a single query

The catalog is rich enough for all of this. The MCP makes it accessible to any AI agent that speaks JSON.

Try It

You can query the BuyWhere MCP server directly via curl -- no SDK install required:

curl -X POST https://api.buywhere.ai/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "search_products",
      "arguments": {
        "query": "MacBook Air M4",
        "country_code": "SG",
        "limit": 5
      }
    }
  }'

Or install the Python SDK:

pip install buywhere-mcp

The server runs locally (or on your agent's infrastructure) and connects to the BuyWhere catalog API. 13 tools, full CRUD on products, deals, merchants, and affiliate redirects.

The Bottom Line

I spent 20 minutes writing a script and now I have a personal price-comparison agent that never sleeps. It works on groceries, electronics, anything in the catalog.

The MCP server is open source. The catalog has 370M+ products. The redirect system handles affiliate tagging.

Build something with it.

I Let AI Agents Bid on My Groceries for a Week

BuyWhere — Wed, 02 Sep 2026 17:55:32 +0000

Test body

Compare two products with BuyWhere MCP compare_products_v2 (2026)

BuyWhere — Wed, 02 Sep 2026 16:52:42 +0000

Compare two products with BuyWhere MCP `compare_products_v2`

You do not need a scraper farm to answer "which of these two laptops is cheaper right now." BuyWhere's MCP server exposes compare_products_v2 over JSON-RPC at https://api.buywhere.ai/mcp.

Live listing: Smithery · Glama

Why this exists

Affiliate product cards on BuyWhere intent pages (for example best gaming laptops US and best 4K monitors Singapore) already route through /r/ merchant links. Agents should use the same catalog, not HTML.

The remote MCP surface currently lists 13 tools (search_products + *_v2 variants). compare_products_v2 is the one that returns a side-by-side price/spec payload.

Minimal Python (stdlib only)

import json, urllib.request

MCP = "https://api.buywhere.ai/mcp"

def rpc(method, params=None, id=1):
    body = json.dumps({"jsonrpc": "2.0", "id": id, "method": method, "params": params or {}}).encode()
    req = urllib.request.Request(MCP, data=body, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

# 1. list tools (sanity)
tools = [t["name"] for t in rpc("tools/list")["result"]["tools"]]
assert "compare_products_v2" in tools

# 2. search two SKUs in one country
def search(q, country="US"):
    res = rpc("tools/call", {
        "name": "search_products_v2",
        "arguments": {"query": q, "country": country, "limit": 5},
    })
    return res

print(search("gaming laptop rtx 4070"))

Call compare_products_v2 with two product ids from the search result. Always read nested price.amount / price.currency — the catalog does not flatten those fields.

Guardrails that actually matter

Currency is nested. Filter price.currency == "USD" or "SGD" before ranking.
US iPhone search still returns accessories. If you asked for a phone and got $13 cases, that is a catalog gap, not a client bug.
Do not scrape merchant URLs. Route humans through BuyWhere /r/ pages; agents use MCP.

Install

Remote: https://api.buywhere.ai/mcp

npx: npx @buywhere/mcp

If you are wiring this into Claude / Cursor / Smithery, the 13-tool list is the source of truth — not a 5-tool smithery.yaml excerpt.

Prices move. Re-query; do not cache a "cheapest" claim in prose.

Query BuyWhere MCP from curl — 13 tools, one JSON body

BuyWhere — Wed, 02 Sep 2026 02:58:33 +0000

Agents should not need an SDK to price-check a product. BuyWhere MCP is at https://api.buywhere.ai/mcp and answers JSON-RPC.

One call

curl -s https://api.buywhere.ai/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"search_products","arguments":{"query":"macbook air m4","country":"SG"}}}'

Prices come back nested: price.amount + price.currency. Filter currency == SGD for Singapore. Flat price fields are a common client bug.

Live listings: Smithery (smithery.ai/servers/BuyWhere/buywhere-mcp) and Glama (glama.ai/mcp/servers/BuyWhere/buywhere-mcp).

Start with search_products then get_product. Do not scrape merchant HTML.

Build an HDB Air Purifier Picker with BuyWhere MCP (Singapore 2026)

BuyWhere — Tue, 01 Sep 2026 20:58:04 +0000

Singapore's "air purifier singapore" queries still pull thousands of impressions with almost no click-through. If you are building an agent that should actually pick a unit for an HDB flat — CADR vs room size, HEPA vs ionizer junk, live prices across Shopee/Lazada/Amazon.sg — you do not want to scrape three storefronts.

This is a ~60-line picker that talks to BuyWhere MCP and returns comparable, in-stock purifiers with merchant-neutral prices.

What you get

One query surface for SG + US catalogs
Prices already normalized (do not treat price as a flat number — it is nested)
Affiliate-safe product pages on buywhere.ai when you want a human fallback

Live comparison page this tutorial points at: Best air purifiers in Singapore.

The nested price field (do not skip)

search_products returns:

{ "price": { "amount": 189.0, "currency": "SGD" }, "title": "..." }

Not price: 189. Filter like this:

def sgd(p):
    pr = p.get("price") or {}
    return pr.get("currency") == "SGD" and isinstance(pr.get("amount"), (int, float))

Minimal picker

import json, os, urllib.request

API = os.environ.get("BUYWHERE_API", "https://api.buywhere.ai")
KEY = os.environ["BUYWHERE_API_KEY"]  # request at https://buywhere.ai

def search(q, country="SG", limit=12):
    body = json.dumps({"query": q, "country": country, "limit": limit}).encode()
    req = urllib.request.Request(
        f"{API}/v1/products/search",
        data=body,
        headers={
            "Authorization": f"Bearer {KEY}",
            "Content-Type": "application/json",
            "User-Agent": "hdb-purifier-picker/1.0",
        },
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=20) as r:
        return json.load(r)

def amount(p):
    pr = p.get("price") or {}
    return pr.get("amount")

def pick(query="hepa air purifier hdb"):
    data = search(query)
    items = data.get("products") or data.get("data") or []
    priced = [x for x in items if sgd(x) and amount(x) and 40 <= amount(x) <= 800]
    priced.sort(key=amount)
    return priced[:6]

def sgd(p):
    pr = p.get("price") or {}
    return pr.get("currency") == "SGD"

if __name__ == "__main__":
    for i, p in enumerate(pick(), 1):
        print(f"{i}. {p.get('title','?')[:70]}  S${amount(p)}  {p.get('merchant') or p.get('store') or ''}")

Agent wiring (Claude / MCP)

If you are on Claude Desktop or any MCP host, add the BuyWhere server (https://api.buywhere.ai/mcp — also listed on Smithery and Glama). Then the same search is a tool call: search_products with country=SG and query="hepa air purifier".

Ask the model to:

Drop ionizer-only SKUs
Keep HEPA / H13 / H14 in the title or specs
Sort by price.amount in SGD
Link the human to /best-air-purifiers-singapore rather than a raw merchant URL

Why this is an AEO page, not a blog post

Google already ranks generic "air purifier singapore" guides. Agents do not. They need a tool plus a canonical comparison URL. The comparison page is the indexable surface; the MCP server is the runtime. Publish both.

Caveats (honest)

Catalog coverage flaps. If a query returns furniture or zero HEPA units, tighten requiredProductTerms (hepa, purifier) and retry — do not invent SKUs.
Currency on some SG rows has historically come back as USD. Always check price.currency.
Affiliate clicks on BuyWhere intent pages go through /r/ — never paste a merchant URL into agent output if you care about attribution.

Request an API key: buywhere.ai · MCP: https://api.buywhere.ai/mcp

Build a Smart Shopping List that Finds Real Prices with BuyWhere MCP

BuyWhere — Tue, 01 Sep 2026 16:30:55 +0000

W9 Dev.to Draft — Build a Smart Shopping List with BuyWhere MCP

Target: Developers building AI apps / agents who need product data
Hook: Shopping lists are boring. Let's make one that actually finds real prices and availability.
Stack: Python, BuyWhere MCP server, rich terminal output
Length: ~900 words, code-first, tutorial format

Metadata

Title: "Build a Smart Shopping List that Finds Real Prices with BuyWhere MCP"
Tags: python, mcp, shopping, tutorial, api
Canonical URL: https://dev.to/buywhere/build-a-smart-shopping-list-with-buywhere-mcp

Body

What We're Building

A CLI shopping list that tracks items across multiple countries, finds the cheapest merchant, and alerts you when prices drop. No scraped HTML, no merchant APIs — just a clean product catalog.

Prerequisites

pip install buywhere-mcp
# or: npx @buywhere/mcp-server

You'll also need the MCP server running. The fastest way:

npx @buywhere/mcp-server --key YOUR_API_KEY

The Core Logic

import asyncio
from buywhere import BuyWhereClient

async def find_best_deal(client, product_query, countries=["US", "SG"]):
    """Find the cheapest price for a product across multiple markets."""
    results = {}

    for country in countries:
        products = await client.search_products(
            query=product_query,
            country=country,
            limit=5
        )
        if products:
            # Sort by price, take the cheapest
            cheapest = min(products, key=lambda p: p["price"]["amount"])
            results[country] = {
                "price": cheapest["price"]["amount"],
                "currency": cheapest["price"]["currency"],
                "merchant": cheapest["merchant"]["name"],
                "url": cheapest["url"]
            }

    return results

async def main():
    client = BuyWhereClient()

    shopping_list = [
        "Sony WH-1000XM5",
        "MacBook Air M4",
        "iPad Air"
    ]

    for item in shopping_list:
        print(f"\n{'='*50}")
        print(f"  {item}")
        print('='*50)

        deals = await find_best_deal(client, item)

        for country, info in deals.items():
            flag = "🇺🇸" if country == "US" else "🇸🇬"
            print(f"  {flag} {country}: {info['currency']} {info['price']:.2f} @ {info['merchant']}")

        best = min(deals.values(), key=lambda x: x["price"])
        print(f"\n  → Best deal: {best['currency']} {best['price']:.2f} in {[c for c, d in deals.items() if d == best][0]}")

if __name__ == "__main__":
    asyncio.run(main())

Why This Works

The BuyWhere catalog covers 370M+ products across 940K+ merchants. The search_products tool does the heavy lifting:

Country filtering — country: "SG" returns SGD prices and SG-available merchants
Merchant data — each result includes the merchant name and a tracking URL
Price objects — prices are structured ({amount, currency}) so you never mix SGD with USD

Adding Price Alerts

The real value: monitoring prices over time.

from datetime import datetime, timedelta

async def check_price_history(client, product_query, days=7):
    """Check if a product's price has changed in the last N days."""

    products = await client.search_products(query=product_query, limit=10)

    for product in products:
        last_updated = product.get("updated_at")
        if last_updated:
            age = datetime.now() - datetime.fromisoformat(last_updated)
            if age < timedelta(days=days):
                print(f"  Recently updated: {product['name']} — {product['price']}")

Cross-Border Arbitrage

The killer feature: find the same product cheaper in another market.

async def arbitrage_check(client, product_query):
    """Check if the same product is cheaper across borders."""
    sg_results = await client.search_products(query=product_query, country="SG", limit=3)
    us_results = await client.search_products(query=product_query, country="US", limit=3)

    if not sg_results or not us_results:
        return None

    sg_cheapest = min(sg_results, key=lambda p: p["price"]["amount"])
    us_cheapest = min(us_results, key=lambda p: p["price"]["amount"])

    # Convert USD to SGD for comparison (approximate)
    us_price_sgd = us_cheapest["price"]["amount"] * 1.35  # rough SGD rate

    if us_price_sgd < sg_cheapest["price"]["amount"]:
        savings = sg_cheapest["price"]["amount"] - us_price_sgd
        return {
            "product": sg_cheapest["name"],
            "sg_price": f"SGD {sg_cheapest['price']['amount']:.2f}",
            "us_price_converted": f"SGD {us_price_sgd:.2f}",
            "savings": f"SGD {savings:.2f}",
            "merchant": us_cheapest["merchant"]["name"]
        }

    return None

Connecting to a Real App

This isn't just a toy. Swap the print statements for a notification:

import os
import smtplib

def notify_deal(deal):
    message = f"""
    Price alert for {deal['product']}:
    Buy from {deal['merchant']} for {deal['savings']} less.
    {deal['url']}
    """
    # Send via your preferred channel
    print(message)  # or: slack_message(message), telegram_message(message)

The MCP Advantage

Traditional price tracking requires:

Scraping merchant sites (fragile, often blocked)
Negotiating affiliate API access (slow, requires partnerships)
Manual price updates (error-prone)

BuyWhere MCP gives you a structured, maintained product catalog with merchant tracking built in. The catalog is refreshed continuously — no scraping infrastructure required.

Getting Your API Key

Sign up at buywhere.ai/developers — free tier includes 1,000 searches/month. The MCP server handles rate limiting and retries automatically.

What's Next

Add currency conversion with live exchange rates
Store results in a SQLite database for history
Add merchant rating filtering
Build a weekly digest email

The full code is on GitHub (placeholder link). Questions? Drop them below or open an issue on the MCP server repo.

Word count: ~880 words
Code blocks: 6
Estimated read time: 5 minutes
CTA: Get your API key at buywhere.ai/developers

Build a 4K monitor price watcher for Singapore with BuyWhere MCP

BuyWhere — Tue, 01 Sep 2026 15:17:26 +0000

A 32-inch 4K panel in Singapore still jumps S$80–S$200 on sale days. Brand pages lag. Agent-readable prices do not.

This is a 40-line watcher that queries BuyWhere's MCP, filters SGD 4K monitors, and prints a ranked table. Pair it with the live comparison pages — they now render /r/ merchant links again (probed 2026-09-01):

Best 4K monitors in Singapore — BenQ MA270UP, PV3200U, AORUS FO32U live
Best budget TVs in the US

Why MCP, not six retailer APIs

Shopee, Lazada, Amazon, and local electronics shops do not share a schema. BuyWhere's MCP (search_products) returns price.amount + price.currency nested under price. Always read it nested:

cur = item.get("price", {}).get("currency")
amt = item.get("price", {}).get("amount")

If you flatten those fields you will silently drop SGD rows. That is the #1 integration bug we see.

Install

pip install mcp
# or call the HTTP catalog:
# GET https://buywhere.ai/api/search?country=SG&query=4k%20monitor

Watcher

import json, urllib.parse, urllib.request

def search(q, country="SG"):
    url = "https://buywhere.ai/api/search?" + urllib.parse.urlencode({"country": country, "query": q})
    req = urllib.request.Request(url, headers={"User-Agent": "4k-monitor-watcher/1.0", "Accept": "application/json"})
    with urllib.request.urlopen(req, timeout=20) as r:
        data = json.loads(r.read())
    return data if isinstance(data, list) else data.get("data") or data.get("results") or []

def priced(items):
    out = []
    for x in items:
        p = x.get("price") or {}
        if isinstance(p, dict) and p.get("currency") == "SGD" and p.get("amount"):
            out.append((float(p["amount"]), x.get("title") or x.get("name"), p["currency"]))
    return sorted(out, key=lambda t: t[0])[:8]

for q in ("4k monitor", "4k oled monitor", "27 4k ips"):
    rows = priced(search(q))
    print(f"\n== {q} ({len(rows)} SGD-priced) ==")
    for amt, title, cur in rows:
        print(f"  {cur} {amt:8.2f}  {title[:70]}")

Run it on a cron. When a SKU drops below your threshold, post to Slack / Telegram (see last week's bot: Dev.to 4545487).

What the live page already does for you

https://buywhere.ai/best-4k-monitors-singapore is an intent page: current-year title, product cards, /r/direct/{id} merchant hops (never raw merchant URLs), and an MCP snippet on the page. Use it as the human-readable counterpart of this watcher. Do not scrape the HTML for prices — call the search API.

Caveats (honest)

Catalog coverage flaps. A query that returns 20 hits at 15:00Z can return 0 at 16:00Z. Retry with backupQueries.
Currency is nested. US pages can leak USD into an SG search; filter currency == "SGD".
Affiliate clicks only fire if the product card rendered a /r/ href. If a page shows an empty state, the watcher still works — the HTML page is the SEO surface, the API is the agent surface.

Wire this into Claude Desktop / Cursor via the BuyWhere MCP listing on Smithery. Tool name: search_products.

Questions: open an issue on BuyWhere/buywhere-mcp.

Build a CLI tool that finds the best deals across marketplaces in real-time

BuyWhere — Tue, 01 Sep 2026 10:24:31 +0000

Price comparison shouldn't require opening a dozen browser tabs.

A CLI tool fixes this. One command, instant results from all major marketplaces, sorted by price — with affiliate links ready to click.

This post builds that tool in under 80 lines of Python using the BuyWhere MCP server.

What you need

BuyWhere MCP server — searches across Shopee, Lazada, Amazon, Qoo10 in one call
Python 3.10+ — the runtime

The tool code

Create price_finder.py:

#!/usr/bin/env python3
"""
price_finder.py — Find the cheapest prices across marketplaces.

Usage:
    python price_finder.py "macbook air m4" --country SG
    python price_finder.py "iphone 16" --limit 3 --currency USD
"""

import argparse
import json
import subprocess
from typing import List, Dict

def search_products(query: str, country: str = "SG", limit: int = 10) -> List[Dict]:
    """Search products via BuyWhere MCP server."""
    result = subprocess.run(
        [
            "npx", "-y", "@buywhere/mcp-server",
            "search",
            "--query", query,
            "--country", country.lower(),
            "--limit", str(limit)
        ],
        capture_output=True, text=True, timeout=30
    )

    if result.returncode != 0:
        return []

    try:
        data = json.loads(result.stdout)
        products = data.get("products", data.get("data", []))
        return products
    except json.JSONDecodeError:
        return []

def format_price(product: Dict) -> str:
    """Extract and format price from product."""
    price_field = product.get("price", {})
    if isinstance(price_field, dict):
        amount = price_field.get("amount")
        currency = price_field.get("currency", "SGD")
    else:
        amount = price_field
        currency = "SGD"

    if amount is None:
        return "Price unavailable"

    symbols = {"SGD": "S$", "USD": "$", "MYR": "RM", "GBP": "£"}
    symbol = symbols.get(currency, currency)
    return f"{symbol}{amount:,.2f}"

def print_results(products: List[Dict], query: str):
    """Print formatted results to stdout."""
    if not products:
        print(f"❌ No products found for \"{query}\"")
        return

    # Sort by price
    priced_products = []
    for p in products:
        price = p.get("price", {})
        if isinstance(price, dict) and price.get("amount"):
            priced_products.append((price["amount"], p))

    priced_products.sort(key=lambda x: x[0])

    print(f"\n🔍 Results for \"{query}\" ({len(products)} found):\n")

    for i, (price, product) in enumerate(priced_products[:10], 1):
        name = product.get("name", product.get("title", "Unknown"))
        merchant = product.get("merchantName", product.get("merchant", "Unknown"))
        url = product.get("url", product.get("productUrl", ""))

        # Truncate long names
        if len(name) > 55:
            name = name[:52] + "..."

        formatted_price = format_price(product)
        redirect_url = f"https://buywhere.ai/r/direct/{product.get('merchantId', '')}"

        print(f"{i}. {name}")
        print(f"   💰 {formatted_price} @ {merchant}")
        print(f"   🔗 {redirect_url}")
        print()

def main():
    parser = argparse.ArgumentParser(
        description="Find the cheapest prices across marketplaces",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python price_finder.py "macbook air m4" --country SG
  python price_finder.py "nintendo switch" --limit 5
  python price_finder.py "sony wh-1000xm5" --country MY
        """
    )

    parser.add_argument("query", help="Product to search for")
    parser.add_argument("--country", "-c", default="SG",
                       choices=["SG", "MY", "US", "UK"],
                       help="Country code (default: SG)")
    parser.add_argument("--limit", "-l", type=int, default=10,
                       help="Max results (default: 10)")

    args = parser.parse_args()

    products = search_products(args.query, args.country, args.limit)
    print_results(products, args.query)

if __name__ == "__main__":
    main()

Make it executable

chmod +x price_finder.py

Use it

# Search in Singapore
./price_finder.py "macbook air m4" --country SG

# Get top 3 results
./price_finder.py "iphone 16" --limit 3

# Search in Malaysia
./price_finder.py "ps5 pro" --country MY

Example output

$ ./price_finder.py "sony wh-1000xm5" --country SG

🔍 Results for "sony wh-1000xm5" (5 found):

1. Sony WH-1000XM5 Wireless Noise Cancelling Headphones
   💰 S$449.00 @ Courts
   🔗 https://buywhere.ai/r/direct/12345

2. Sony WH-1000XM5 Headphones Black
   💰 S$459.00 @ Challenger
   🔗 https://buywhere.ai/r/direct/67890

3. Sony WH-1000XM5 - Silver
   💰 S$479.00 @ Best Denki
   🔗 https://buywhere.ai/r/direct/11111

Add shell completion

Create price_finder_completion.sh:

#!/bin/bash
# Bash completion for price_finder.py

_price_finder_completion() {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    case "$prev" in
        --country|-c)
            COMPREPLY=($(compgen -W "SG MY US UK" -- "$cur"))
            ;;
        --limit|-l)
            COMPREPLY=($(compgen -W "5 10 20 50" -- "$cur"))
            ;;
        *)
            ;;
    esac
}

complete -F _price_finder_completion ./price_finder.py

Source it:

source price_finder_completion.sh

Now Tab completes country codes and limits.

Add a global shortcut

symlink to your path:

ln -s $(pwd)/price_finder.py ~/.local/bin/price-finder

Use from anywhere:

price-finder "nintendo switch" --country SG

What makes this useful

Fast: One command, instant results. No browser tabs.
Portable: Works on Linux, macOS, Windows (WSL).
Scriptable: Pipe results to other tools (jq, awk).
Always fresh: Prices come from live catalog, not cached data.

Integration ideas

# Find cheapest option, open directly
price-finder "macbook air m4" | head -5 | grep "https://" | xargs open

# Compare prices across countries
for country in SG MY US; do
    echo "--- $country ---"
    price-finder "ps5 pro" --country $country | head -3
done

# Watch for price drops (cron job)
price-finder "nintendo switch 2" > ~/ps5-prices.log

Get the MCP server

npx -y @buywhere/mcp-server

# Or the Python package
pip install buywhere-mcp

The CLI tool runs the MCP server as a subprocess on each search — no daemon or database needed.

This is part of a series on building AI shopping agents with BuyWhere MCP. Previous posts covered the MCP server basics, connecting Claude to a real product catalog, building a ReAct shopping agent, price tracking with cron jobs, a Telegram bot, and more.

Series:

Build a Telegram bot that compares prices across Shopee, Lazada, and Amazon

BuyWhere — Tue, 01 Sep 2026 10:16:28 +0000

Shopping across multiple platforms is tedious. Shopee has good prices on some things, Lazada on others, Amazon wins on electronics. But comparing manually takes time.

A Telegram bot fixes this. Give it a product name, it searches across all three platforms, and returns the cheapest option — with a direct affiliate link so the purchase is tracked.

This post builds that bot in under 100 lines of Python using the BuyWhere MCP server and the Telegram Bot API.

What you need

BuyWhere MCP server — searches across Shopee, Lazada, Amazon, Qoo10, and others in one call
Telegram Bot — created via @BotFather
Python 3.10+ — the runtime

Step 1: Create your Telegram bot

Open Telegram and message @BotFather
Send /newbot
Follow the prompts — give it a name and username
Copy the API token it gives you

Keep the token private. You'll pass it as an environment variable.

Step 2: Install dependencies

pip install python-telegram-bot buywhere-mcp

Or if you prefer the MCP server directly:

npx -y @buywhere/mcp-server

For this post we'll use the Python MCP client.

Step 3: The bot code

import os
import re
import subprocess
import json
from telegram import Update
from telegram.ext import (
    Application, CommandHandler, MessageHandler,
    filters, ContextTypes
)

# Load your bot token from environment
TELEGRAM_TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]

def search_products(query: str, country: str = "SG") -> list[dict]:
    """Search products via BuyWhere MCP server."""
    result = subprocess.run(
        [
            "npx", "-y", "@buywhere/mcp-server",
            "search",
            "--query", query,
            "--country", country.lower(),
            "--limit", "10"
        ],
        capture_output=True, text=True, timeout=30
    )
    if result.returncode != 0:
        return []
    try:
        data = json.loads(result.stdout)
        products = data.get("products", data.get("data", []))
        return products
    except json.JSONDecodeError:
        return []

def format_price(product: dict) -> str:
    """Extract formatted price from product."""
    price_field = product.get("price", {})
    if isinstance(price_field, dict):
        amount = price_field.get("amount")
        currency = price_field.get("currency", "SGD")
    else:
        amount = price_field
        currency = "SGD"

    if amount is None:
        return "Price unavailable"

    symbol = "S$" if currency == "SGD" else ("$" if currency == "USD" else currency)
    return f"{symbol}{amount:,.2f}"

def product_to_message(product: dict, index: int) -> str:
    """Format a product result as a Telegram message."""
    name = product.get("name", product.get("title", "Unknown product"))
    # Truncate long names
    if len(name) > 60:
        name = name[:57] + "..."

    price = format_price(product)
    merchant = product.get("merchantName", product.get("merchant", "Unknown merchant"))
    url = product.get("url", product.get("productUrl", ""))

    # Use /r/ redirect for affiliate tracking
    redirect_url = f"https://buywhere.ai/r/direct/{product.get('merchantId', '')}?pathname=/telegram-search"

    lines = [
        f"{index}. {name}",
        f"   💰 {price} @ {merchant}",
        f"   🔗 {redirect_url}",
    ]
    return "\n".join(lines)

def build_response(query: str, products: list[dict]) -> str:
    """Build the full response message."""
    header = f"🔍 Results for *\"{query}\"*:\n"

    if not products:
        return (
            f"🔍 Results for *\"{query}\"*:\n\n"
            "No products found. Try a different search term."
        )

    lines = [header]
    for i, product in enumerate(products[:5], 1):
        lines.append(product_to_message(product, i))

    footer = (
        f"\n_Showing top 5 of {len(products)} results. "
        "Prices updated in real-time via BuyWhere MCP._"
    )
    lines.append(footer)

    return "\n".join(lines)

async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle /start command."""
    await update.message.reply_text(
        "👋 Welcome to PriceBot!\n\n"
        "Send me any product name and I'll search across "
        "Shopee, Lazada, Amazon, and more — then show you the best deals.\n\n"
        "Try: *iPhone 16*, *Dyson V15*, *Nike shoes*\n\n"
        "_Powered by BuyWhere MCP_",
        parse_mode="Markdown"
    )

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle /help command."""
    await update.message.reply_text(
        "📖 *How to use PriceBot:*\n\n"
        "Just type any product name to search.\n\n"
        "Examples:\n"
        "• iPhone 16 256GB\n"
        "• Sony WH-1000XM5\n"
        "• Nintendo Switch 2\n\n"
        "I'll return the top 5 cheapest options across major marketplaces."
    )

async def search_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle text search queries."""
    query = update.message.text.strip()

    if len(query) < 3:
        await update.message.reply_text(
            "🔍 Please enter at least 3 characters to search."
        )
        return

    if len(query) > 100:
        await update.message.reply_text(
            "🔍 Search query too long. Try a shorter product name."
        )
        return

    # Let user know we're searching
    search_msg = await update.message.reply_text(
        f"🔍 Searching for \"{query}\"..."
    )

    # Run the search
    products = search_products(query)

    # Send results
    response = build_response(query, products)
    await update.message.reply_text(
        response,
        parse_mode="Markdown",
        disable_web_page_preview=True
    )

    # Delete the "searching" message
    try:
        await search_msg.delete()
    except Exception:
        pass

def main():
    """Run the bot."""
    print("Starting PriceBot...")

    app = Application.builder().token(TELEGRAM_TOKEN).build()

    # Add handlers
    app.add_handler(CommandHandler("start", start_command))
    app.add_handler(CommandHandler("help", help_command))
    app.add_handler(MessageHandler(
        filters.TEXT & ~filters.COMMAND,
        search_handler
    ))

    print("Bot is running. Press Ctrl+C to stop.")
    app.run_polling()

if __name__ == "__main__":
    main()

Step 4: Run it

export TELEGRAM_BOT_TOKEN="your-token-here"
python price_bot.py

Your bot is now live. Message it from Telegram.

What it looks like

Send: MacBook Air M4

Response:

🔍 Results for *"MacBook Air M4"*:

1. Apple MacBook Air 15 M4 24GB 512GB
   💰 S$2,249.00 @ Challengersg
   🔗 https://buywhere.ai/r/direct/12345

2. Apple MacBook Air 15 M4 16GB 256GB
   💰 S$2,049.00 @ BestBuy
   🔗 https://buywhere.ai/r/direct/67890

3. Apple MacBook Air 13 M4 16GB 256GB
   💰 S$1,849.00 @ Courts
   🔗 https://buywhere.ai/r/direct/11111
...

Deployment

For a persistent bot, deploy it to:

Railway — pip install -r requirements.txt, set the env var, deploy
Fly.io — fly launch, set secrets, fly deploy
A Raspberry Pi at home — systemd service, always on

The bot needs no database. Each search is stateless.

Adding country support

The bot defaults to Singapore. Add country selection:

COUNTRY_MAP = {
    "🇸🇬": "SG",
    "🇲🇾": "MY",
    "🇺🇸": "US",
    "🇬🇧": "UK",
}

async def country_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton(flag, callback_data=code)]
        for flag, code in COUNTRY_MAP.items()
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text(
        "🌍 Select your country:",
        reply_markup=reply_markup
    )

Users pick their country once, and all subsequent searches use it.

What BuyWhere adds

Without BuyWhere, the bot would need separate API calls to each platform:

Shopee API (requires authentication, rate-limited)
Lazada API (requires platform contract)
Amazon API (Product Advertising API, requires approval)
Qoo10 API (different auth format)

The MCP server normalizes all of this into one query and returns structured results. Your bot code stays simple.

Get the MCP server

npx -y @buywhere/mcp-server

# Or the Python package
pip install buywhere-mcp

The bot runs the MCP server as a subprocess on each search — no long-running daemon needed.

Series: