Forem: BuyWhere

Add price drop alerts to any app using the BuyWhere API

BuyWhere — Sat, 25 Apr 2026 16:42:55 +0000

If your app already helps users discover products, the next useful feature is usually not more search. It is memory.

Users do not just want to know what a product costs right now. They want to know when it gets cheaper.

That makes price drop alerts a strong fit for BuyWhere, the definitive product catalog for AI agents. You can use the same product search endpoint you already call for discovery, run it on an interval, compare the latest price to a saved baseline, and trigger an alert when the delta crosses your threshold.

This tutorial shows the simplest production-shaped version of that workflow:

search for products with BuyWhere
store the product and starting price your user wants to track
poll BuyWhere on a schedule
compare the latest price against the stored baseline
send an email, push notification, Slack message, or in-app alert when the price falls

The canonical endpoint is:

GET /v1/products/search

Why this matters for developers

Price alerts are a strong retention feature because they turn one search session into an ongoing workflow.

Instead of forcing users to check the same product manually, your app can:

remember what they care about
monitor price movement for them
bring them back only when the timing is better

The important part is that you do not need a second integration surface to build this. BuyWhere can handle both discovery and monitoring through the same search API.

The core pattern

The implementation is intentionally simple:

your user chooses a product to track
your app stores the current price as a baseline
a scheduled job reruns the same BuyWhere search
your app finds the matching product and compares the latest price
if the drop is large enough, your app sends the alert

BuyWhere handles product retrieval. Your application handles state and notifications.

Search for the tracked product

Start with the same request you would use for product discovery:

curl -sS "https://api.buywhere.ai/v1/products/search?q=airpods+pro&country_code=SG&limit=5" \
  -H "Authorization: Bearer $BUYWHERE_API_KEY"

For alert workflows, the most useful fields in the response are:

id
title
price
domain
url
country_code

Save a baseline in your app

For a first implementation, store:

the user id
the BuyWhere product id
the original query
the country code
the merchant domain if you want merchant-specific tracking
the baseline price
the drop threshold
the notification channel

Example:

{
  "user_id": "user_123",
  "product_id": "bw_sg_12345",
  "query": "airpods pro",
  "country_code": "SG",
  "domain": "lazada.sg",
  "baseline_price": 349.0,
  "target_drop_amount": 20.0,
  "notification_channel": "email"
}

Prefer BuyWhere id for matching. If you cannot store it yet, use the original query, narrow with domain, and fall back to url matching carefully.

Python example

import os
from dataclasses import dataclass

import requests


API_KEY = os.environ["BUYWHERE_API_KEY"]
BASE_URL = "https://api.buywhere.ai"


@dataclass
class TrackedItem:
    user_id: str
    product_id: str
    query: str
    country_code: str
    domain: str
    baseline_price: float
    target_drop_amount: float
    notification_channel: str


def search_products(query: str, country_code: str, domain: str, limit: int = 10):
    response = requests.get(
        f"{BASE_URL}/v1/products/search",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={
            "q": query,
            "country_code": country_code,
            "domain": domain,
            "limit": limit,
        },
        timeout=15,
    )
    response.raise_for_status()
    return response.json().get("data", [])


def find_tracked_product(products, product_id):
    for product in products:
        if product.get("id") == product_id:
            return product
    return None


def should_alert(baseline_price: float, current_price: float, target_drop_amount: float):
    return baseline_price - current_price >= target_drop_amount


def send_alert(item: TrackedItem, product: dict):
    print(
        f"[alert] user={item.user_id} "
        f"title={product['title']} "
        f"old_price={item.baseline_price} "
        f"new_price={product['price']} "
        f"url={product['url']}"
    )


def check_price_drop(item: TrackedItem):
    products = search_products(
        query=item.query,
        country_code=item.country_code,
        domain=item.domain,
    )
    product = find_tracked_product(products, item.product_id)

    if not product:
        return

    current_price = float(product["price"])

    if should_alert(item.baseline_price, current_price, item.target_drop_amount):
        send_alert(item, product)


tracked_item = TrackedItem(
    user_id="user_123",
    product_id="bw_sg_12345",
    query="airpods pro",
    country_code="SG",
    domain="lazada.sg",
    baseline_price=349.0,
    target_drop_amount=20.0,
    notification_channel="email",
)

check_price_drop(tracked_item)

That example prints an alert, but the same hook can trigger email, push, Slack, Discord, or an in-app notification.

JavaScript example

If your app backend is JavaScript or TypeScript, the pattern is the same:

const apiKey = process.env.BUYWHERE_API_KEY;

async function searchProducts({ query, countryCode, domain, limit = 10 }) {
  const params = new URLSearchParams({
    q: query,
    country_code: countryCode,
    domain,
    limit: String(limit),
  });

  const response = await fetch(
    `https://api.buywhere.ai/v1/products/search?${params.toString()}`,
    {
      headers: {
        Authorization: `Bearer ${apiKey}`,
      },
    }
  );

  if (!response.ok) {
    throw new Error(`BuyWhere request failed: ${response.status}`);
  }

  const payload = await response.json();
  return payload.data ?? [];
}

function shouldAlert(baselinePrice, currentPrice, targetDropAmount) {
  return baselinePrice - currentPrice >= targetDropAmount;
}

async function checkPriceDrop(trackedItem) {
  const products = await searchProducts({
    query: trackedItem.query,
    countryCode: trackedItem.countryCode,
    domain: trackedItem.domain,
  });

  const product = products.find((item) => item.id === trackedItem.productId);
  if (!product) return;

  if (
    shouldAlert(
      trackedItem.baselinePrice,
      Number(product.price),
      trackedItem.targetDropAmount
    )
  ) {
    console.log({
      userId: trackedItem.userId,
      title: product.title,
      oldPrice: trackedItem.baselinePrice,
      newPrice: product.price,
      url: product.url,
    });
  }
}

That is enough to drop into a Next.js route, Express worker, serverless cron job, or queue consumer.

Decide what counts as a price drop

The simplest rule is:

alert when baseline_price - current_price >= threshold

Example:

baseline 349
current price 329
threshold 20
result: send the alert

This keeps the logic predictable and avoids noisy notifications from tiny price changes.

Prevent duplicate alerts

A scheduled job will keep finding the same lower price unless you store alert history.

A simple first fix is to record:

last_alerted_price
last_alerted_at
status

Then only re-alert when the price drops again beyond the last alerted price, or when the item has never been alerted before.

Run it on a schedule

You can start with:

cron
a background worker
a serverless scheduler
GitHub Actions for a prototype

Example cron entry:

0 * * * * /usr/bin/python3 /path/to/check_price_drops.py

Hourly or daily checks are enough for a first release.

The user-facing message

Your alert should tell the user:

what changed
how much they can save now
where to go next

Example:

Price drop detected: AirPods Pro is now SGD 329, down from SGD 349.
Buy now: https://lazada.sg/products/airpods-pro

That is enough to turn BuyWhere search into a retention loop instead of a one-time lookup.

Start with one narrow workflow

Do not overbuild version one.

Start with:

one product per alert
one notification channel
one simple threshold rule
one scheduled polling job

If you already have BuyWhere search working, price drop alerts are a straightforward next step.

Get your API key and quickstart at buywhere.ai/developers/.

Build a Real-Time Price Comparison Widget with BuyWhere API

BuyWhere — Sat, 25 Apr 2026 16:42:01 +0000

If you want to add live price comparison to a landing page, shopping assistant, or merchant dashboard, the UI is usually the easy part. The painful part is getting product data from multiple retailers in a shape your frontend can actually use.

BuyWhere API gives you a live comparison route for that job. Instead of stitching together merchant-specific integrations, you can call GET /v2/agents/price-comparison, get back structured listings, and render a comparison widget immediately.

This guide keeps the implementation narrow on purpose:

one backend proxy route
one browser widget
one production-safe architecture

The goal is not to build a perfect shopping app in one pass. The goal is to get to a credible first version quickly, with code you can keep.

Use the Endpoint That Matches the UI

For this use case, build on the live agent-native route:

Base URL: https://api.buywhere.ai
Auth header: Authorization: Bearer <your-key>
Endpoint: GET /v2/agents/price-comparison

Useful query parameters:

product_name
limit
sources
availability_only
min_price
max_price
sort_by

If your UI is specifically about comparing offers for one product query, this route is a better fit than a generic search endpoint.

Keep the API Key Off the Client

Do not put your BuyWhere API key in frontend JavaScript.

The correct architecture is:

Browser widget -> your backend /api/compare -> BuyWhere /v2/agents/price-comparison

That gives you:

server-side key storage
a clean place for caching and rate limiting
a smaller browser payload

Step 1: Get an API Key

Create a key at https://buywhere.ai/developers/ and export it:

export BUYWHERE_API_KEY="bw_live_your_key_here"
export BUYWHERE_BASE_URL="https://api.buywhere.ai"

Smoke-test the live route directly:

curl --get "$BUYWHERE_BASE_URL/v2/agents/price-comparison" \
  -H "Authorization: Bearer $BUYWHERE_API_KEY" \
  --data-urlencode "product_name=sony wh-1000xm5" \
  --data-urlencode "limit=5" \
  --data-urlencode "sort_by=price_asc"

If that works, your next problem is not API access. It is response shaping and UI rendering.

Step 2: Add a Minimal Backend Proxy

Here is a minimal Express handler:

import express from "express";

const app = express();
const API_KEY = process.env.BUYWHERE_API_KEY;
const BASE_URL = process.env.BUYWHERE_BASE_URL || "https://api.buywhere.ai";

app.use(express.static("public"));

app.get("/api/compare", async (req, res) => {
  const productName = String(req.query.product_name || "").trim();

  if (!productName) {
    return res.status(400).json({ error: "product_name is required" });
  }

  const params = new URLSearchParams({
    product_name: productName,
    limit: String(req.query.limit || 8),
    sort_by: String(req.query.sort_by || "price_asc"),
  });

  if (req.query.availability_only === "true") {
    params.set("availability_only", "true");
  }

  const rawSources = typeof req.query.sources === "string"
    ? req.query.sources.split(",")
    : [];

  for (const source of rawSources) {
    const normalized = source.trim();
    if (normalized) params.append("sources", normalized);
  }

  const response = await fetch(`${BASE_URL}/v2/agents/price-comparison?${params.toString()}`, {
    headers: {
      Authorization: `Bearer ${API_KEY}`,
    },
  });

  const data = await response.json();

  if (!response.ok) {
    return res.status(response.status).json(data);
  }

  return res.json({
    query: data.query,
    total_results: data.total_results,
    query_time_ms: data.query_time_ms,
    price_stats: data.price_stats,
    results: (data.results || []).map((item) => ({
      title: item.title,
      source: item.source,
      price: item.price,
      currency: item.currency,
      rating: item.rating,
      price_rank: item.price_rank,
      in_stock: item.in_stock,
      affiliate_url: item.affiliate_url || item.url,
    })),
  });
});

That is enough to give the browser a stable, minimal response contract.

Step 3: Render the Widget in the Browser

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>BuyWhere Price Comparison Widget</title>
  </head>
  <body>
    <h1>Real-Time Price Comparison</h1>

    <form id="search-form">
      <input id="query" value="sony wh-1000xm5" aria-label="Search query" />
      <button type="submit">Compare Prices</button>
    </form>

    <p id="status">No results yet.</p>
    <table>
      <thead>
        <tr>
          <th>Product</th>
          <th>Price</th>
          <th>Source</th>
          <th>Rating</th>
          <th>Link</th>
        </tr>
      </thead>
      <tbody id="results-body">
        <tr><td colspan="5">No results yet.</td></tr>
      </tbody>
    </table>

    <script>
      const resultsBody = document.getElementById("results-body");
      const statusEl = document.getElementById("status");

      async function fetchProducts(query) {
        const url = new URL("/api/compare", window.location.origin);
        url.searchParams.set("product_name", query);
        url.searchParams.set("limit", "8");
        url.searchParams.set("sort_by", "price_asc");

        const response = await fetch(url);
        const data = await response.json();

        if (!response.ok) {
          throw new Error(data.error || `Request failed with ${response.status}`);
        }

        return data;
      }

      function renderRows(items) {
        if (!items.length) {
          resultsBody.innerHTML = '<tr><td colspan="5">No products found.</td></tr>';
          return;
        }

        resultsBody.innerHTML = items.map((item) => `
          <tr>
            <td>${item.title}</td>
            <td>${item.currency} ${item.price}</td>
            <td>${item.source}</td>
            <td>${item.rating ?? "N/A"}</td>
            <td><a href="${item.affiliate_url}" target="_blank" rel="noreferrer">Open</a></td>
          </tr>
        `).join("");
      }

      document.getElementById("search-form").addEventListener("submit", async (event) => {
        event.preventDefault();

        const query = document.getElementById("query").value.trim();
        statusEl.textContent = "Loading...";
        resultsBody.innerHTML = '<tr><td colspan="5">Loading...</td></tr>';

        try {
          const data = await fetchProducts(query);
          renderRows(data.results || []);
          statusEl.textContent = `Loaded ${data.total_results} offers in ${data.query_time_ms} ms.`;
        } catch (error) {
          statusEl.textContent = error.message;
          resultsBody.innerHTML = `<tr><td colspan="5">${error.message}</td></tr>`;
        }
      });
    </script>
  </body>
</html>

This is enough to prove the end-to-end UX without overbuilding the first version.

Step 4: Make It Feel Live

For a real-time feel, add polling every 30 to 60 seconds:

setInterval(() => {
  const query = document.getElementById("query").value.trim();
  if (!query) return;
  document.getElementById("search-form").dispatchEvent(new Event("submit"));
}, 30000);

For most commerce surfaces, that is enough. Real-time does not need to mean requerying every second.

Why This Pattern Works

The main advantage here is not the HTML table. It is the separation of responsibilities:

BuyWhere handles comparison data across sources
your backend handles authentication and response shaping
your frontend handles ranking and presentation

That is the right shape for a feature you expect to keep iterating on.

Production Notes

If you ship this:

keep the key on the server
cache identical requests for a short window
add source and price filters
track outbound affiliate clicks
do not rank only by cheapest price if stock quality and trust matter

Get Started

If you want to build this in your own app, start with the live comparison route and a small backend proxy, not a browser-side API key.

Get your API key at buywhere.ai/developers/.

Give Your AI Agent Real-Time Product Data with BuyWhere

BuyWhere — Sat, 25 Apr 2026 16:41:11 +0000

AI agents are getting better at reasoning, but they still fail on a basic commerce task: answering product questions with current prices and availability.

Ask an agent, "What is the cheapest iPhone 15 right now?" and you often get one of three bad outcomes:

a hallucinated price
a stale answer based on old training data
a summary built from inconsistent or outdated product pages

That is not only a model problem. It is a data access problem.

If you want an agent to answer shopping questions reliably, the model needs a live product source it can query at runtime. That is where BuyWhere fits. Instead of relying on model memory, you let the agent call a product catalog API and reason over fresh, structured results.

In this post, I will show a practical pattern for doing that with BuyWhere so your agent can answer commerce questions with live data instead of guessing.

The problem with product questions in agent workflows

Product queries look easy until you put them in front of an agent.

A user asks:

What is the cheapest iPhone 15 right now?

To answer that well, the agent has to do more than generate text. It needs to:

search live product listings
compare multiple offers
filter out weak or irrelevant matches
return a grounded answer with price, merchant, and link

If you skip the live retrieval step, the model is forced to improvise. That is how you get outdated prices, invented retailer names, or false confidence around availability.

This gets worse in production because users do not separate "model quality" from "data quality." If your agent answers with the wrong price, they blame your product.

The better pattern: retrieval first, reasoning second

The more reliable design is:

let the model interpret the shopper's request
call BuyWhere for live product data
return compact structured results to the model
let the model summarize or compare those results

That keeps the model in the role it is good at: understanding intent and communicating clearly. It gives the data layer responsibility for the part users cannot tolerate being stale: price, availability, and merchant links.

The API calls

For the first integration, keep it small.

Use GET /v1/products when you want the fastest first successful request:

Base URL: https://api.buywhere.ai
Endpoint: GET /v1/products
Query params: q=<query>&limit=<n>
Auth: Authorization: Bearer <your-key>

curl --get "https://api.buywhere.ai/v1/products" \
  -H "Authorization: Bearer $BUYWHERE_API_KEY" \
  --data-urlencode "q=iPhone 15" \
  --data-urlencode "limit=5"

Once that works, switch your agent tool to the agent-native route:

Endpoint: GET /v2/agent-catalog/search
Useful extra fields: confidence_score, availability_prediction, competitor_count, affiliate_url

curl --get "https://api.buywhere.ai/v2/agent-catalog/search" \
  -H "Authorization: Bearer $BUYWHERE_API_KEY" \
  --data-urlencode "q=iPhone 15" \
  --data-urlencode "limit=5" \
  --data-urlencode "include_agent_insights=true"

The important point is not the exact JSON shape. The important point is that your agent is now looking at live product results instead of trying to remember what an iPhone 15 costs.

Claude tool use example

I am using Claude tool use for the integration example because it maps cleanly onto agent workflows: Claude decides when it needs product data, your application calls BuyWhere, and then Claude answers with grounded results.

Here is a minimal Claude tool definition:

{
  "name": "buywhere_search_products",
  "description": "Search BuyWhere for live product data.",
  "input_schema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "source": { "type": "string" },
      "min_price": { "type": "number" },
      "max_price": { "type": "number" },
      "limit": { "type": "integer", "default": 5 }
    },
    "required": ["query"]
  }
}

The model does not need direct internet access. It only needs permission to call your buywhere_search_products tool when a shopping question comes in.

That keeps the integration predictable:

Claude handles intent
BuyWhere handles retrieval
your app handles the HTTP call

Working Python example

This is the smallest useful version of that flow. It calls the agent-native BuyWhere search route, sorts by lowest price, and returns a short answer your agent can use or quote.

import os
import requests

API_KEY = os.environ["BUYWHERE_API_KEY"]
BASE_URL = "https://api.buywhere.ai"


def cheapest_product_answer(query: str) -> str:
    response = requests.get(
        f"{BASE_URL}/v2/agent-catalog/search",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={
            "q": query,
            "limit": 5,
            "include_agent_insights": "true",
        },
        timeout=20,
    )
    response.raise_for_status()

    items = response.json().get("results", [])
    if not items:
        return f"No live results found for {query}."

    cheapest = min(items, key=lambda item: float(item.get("price", float("inf"))))
    title = cheapest.get("title", "Unknown product")
    price = cheapest.get("price", "N/A")
    currency = cheapest.get("currency", "USD")
    source = cheapest.get("source", "unknown retailer")
    url = cheapest.get("affiliate_url") or cheapest.get("url", "")
    return f"{title} is cheapest at {currency} {price} from {source}. {url}"


print(cheapest_product_answer("iPhone 15"))

That is enough to power the core agent answer:

The cheapest iPhone 15 right now is listed at USD X from retailer Y. Here is the link: Z.

You can always add richer behavior later, such as:

filtering by source
removing weak matches
comparing the top three offers instead of only the cheapest
attaching confidence or freshness metadata in the tool result

But the first version should stay simple.

What your agent can answer now

Once this pattern is in place, your agent can answer practical commerce questions that are risky or impossible to answer reliably from model memory alone:

What is the cheapest iPhone 15 right now?
Show me the best wireless headphones under $250.
Compare three live offers for an espresso machine.
Find the lowest-priced Nintendo Switch listing right now.

The model is no longer inventing answers. It is grounding those answers in a runtime API call.

That changes the user experience in an important way.

Instead of sounding smart but being unreliable, the agent becomes operational:

it can cite a live price
it can point to a real merchant
it can link to a real product page

For shopping workflows, that is the difference between a demo and a usable product.

Why this matters for agent builders

Most AI builders do not want to spend their time building retail scrapers, normalizing merchant schemas, or debugging why one marketplace returns broken price strings.

They want to build:

a shopping copilot
a concierge agent
a product research assistant
a deal-finding workflow
a commerce tool inside a broader agent product

BuyWhere gives those builders a cleaner starting point. The model still does the high-level agent work, but the product facts come from a catalog API built for retrieval.

That is a better architecture for three reasons:

1. Better reliability

The answer depends on a live API call, not on whatever the model happened to see during training.

2. Lower implementation overhead

You do not need to stitch together merchant-specific integrations before you can answer a single shopping query.

3. Easier agent design

The tool boundary is clear. The model knows when to search, and your application knows exactly which external system is allowed to provide commerce facts.

A good production pattern

If you take this beyond a toy example, a solid production flow looks like this:

user asks a shopping question
model decides whether it needs live product data
app calls BuyWhere
app trims the result set to the most relevant offers
model writes the final answer using only returned data

The trimming step matters. Do not dump a huge payload back into the model if all it needs is:

title
price
currency
retailer
URL

Keep the tool result compact. Agent systems usually work better when the retrieval layer does the heavy lifting and the prompt context stays lean.

The practical takeaway

If your agent needs to answer commerce questions, do not ask the model to guess prices.

Give it a live product retrieval step.

That single design choice improves trust, makes answers more actionable, and gives you a cleaner path to production shopping workflows.

If you are building with Claude tool use, GPT function calling, or LangChain tools, the pattern is the same:

define one search tool
call BuyWhere at runtime
summarize grounded results

Start there. You can add comparisons, price alerts, and richer agent flows after that works.

BuyWhere is Now on Smithery — Add Singapore Product Search to Claude in One Click

BuyWhere — Sat, 25 Apr 2026 07:13:12 +0000

BuyWhere is now available on the Smithery MCP registry, making it the easiest way to give your Claude Desktop agent access to live Singapore product prices.

What is BuyWhere?

BuyWhere is a real-time product catalog API for AI agents. With a single API call, your agent can search live prices across Harvey Norman, Shopee, Lazada, and 20+ Singapore retailers — covering 1,000+ products updated daily.

One-Click Setup via Smithery

If you use Smithery, you can now install BuyWhere directly from the registry. No config editing required.

Go to smithery.ai/servers/partners/buywhere
Click Install next to Claude Desktop
Paste your API key from buywhere.ai/dashboard

That's it. Your agent can now answer: "Where is the cheapest 65-inch TV in Singapore?"

What Your Agent Can Do

> Where can I buy an LG washing machine in Singapore?

I found the LG F2515NTGW (15kg front loader) at these prices:
• Harvey Norman: S$1,299 (in stock)
• Lazada: S$1,189 (ships in 2–3 days)
• Shopee: S$1,149 with free delivery

Manual Setup (Claude Desktop / Cursor)

If you prefer manual config:

{
  "mcpServers": {
    "buywhere": {
      "command": "npx",
      "args": ["-y", "buywhere-mcp"],
      "env": {
        "BUYWHERE_API_KEY": "your_api_key_here"
      }
    }
  }
}

Remote MCP (for agents that support HTTP)

If your agent supports streamable HTTP transports:

https://api.buywhere.ai/mcp
Authorization: Bearer <your-api-key>

Full API docs: buywhere.ai/developers

Get Your Free API Key

Questions? Reach us at surf@buywhere.ai

BuyWhere MCP: Give Claude Desktop Live Singapore Prices in 2 Minutes

BuyWhere — Sat, 25 Apr 2026 06:54:11 +0000

BuyWhere MCP: Give Claude Desktop Live Singapore Prices in 2 Minutes

Ever asked Claude "What's the cheapest 65-inch TV in Singapore right now?" and got a frustrating "I don't have access to live pricing data"?

That ends today.

BuyWhere is a real-time product catalog API that covers 1,000+ products across Harvey Norman, Shopee, Lazada, and 20+ Singapore retailers. We ship it as an MCP server, so you can wire it into Claude Desktop (and Cursor, Windsurf, or any MCP client) in about two minutes.

What you'll be able to ask Claude after setup

"Compare the price of the Samsung Galaxy S25 across all retailers"
"Find the cheapest washing machine under $500 in Singapore"
"Which retailer has the best deal on AirPods Pro today?"
"Show me the price history for the iPhone 16"

Claude queries BuyWhere in real time and gives you structured, up-to-date answers — no hallucinations about prices, no stale data.

Step 1: Get an API key

Step 2: Edit your Claude Desktop config

Open your MCP config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the BuyWhere server:

{
  "mcpServers": {
    "buywhere": {
      "command": "npx",
      "args": ["-y", "buywhere-mcp"],
      "env": {
        "BUYWHERE_API_KEY": "your_api_key_here"
      }
    }
  }
}

Step 3: Restart Claude Desktop

Quit and reopen Claude Desktop. You'll see "buywhere" appear in the MCP tools indicator.

Step 4: Ask away

Try: "Use BuyWhere to find the best price on a Sony 55-inch TV in Singapore."

Available tools

The BuyWhere MCP server exposes 6 tools:

Tool	What it does
`search_products`	Natural language or keyword product search
`get_product`	Full details for a specific product
`get_price`	Live prices across all merchants
`compare_prices`	Side-by-side comparison of 2–5 products
`get_affiliate_link`	Click-tracked URL for any product
`get_catalog`	Browse available product categories

Works with Cursor and Windsurf too

Same config, different file:

Cursor: ~/.cursor/mcp.json

Windsurf: ~/.windsurf/mcp.json

Remote endpoint for agent developers

If you're building agents in code (LangChain, CrewAI, OpenAI Agents SDK), hit the hosted MCP endpoint directly:

https://api.buywhere.ai/mcp
Authorization: Bearer <your-api-key>

Full API docs: buywhere.ai/developers

Why BuyWhere instead of scraping?

No rate limits from retailer sites
Structured data — prices, names, images, affiliate links already parsed
Updated daily — no stale cache surprises
Legal — we operate under data agreements, not ToS-violating scrapers
Singapore-specific — built for SG consumers, covering the retailers that matter here

Give it a try and let me know what shopping use cases you build! Drop questions in the comments or reach out at surf@buywhere.ai.

BuyWhere: Real-Time Singapore Product Catalog API for AI Agents (MCP-Native)

BuyWhere — Sat, 25 Apr 2026 06:14:02 +0000

BuyWhere: Real-Time Singapore Product Catalog API for AI Agents

If you're building AI agents that handle consumer queries or shopping research in Southeast Asia, you've probably hit the same wall: there's no clean, live data source for product prices.

Scrapers break. Static datasets go stale. Your agent answers questions about prices from three months ago.

That's why BuyWhere was built.

What Is BuyWhere?

BuyWhere is a real-time product catalog API built specifically for AI agents. One API call gives your agent live pricing data across:

Harvey Norman
Shopee
Lazada

1,000+ products. Updated daily. No scraping required.

The Problem It Solves

Your user asks: "What's the cheapest 65-inch TV in Singapore right now?"

Without BuyWhere, your agent either:

Hallucinates a price from training data
Tells the user it can't access real-time info
Tries to scrape a site and fails

With BuyWhere, your agent makes one API call and returns actual, current prices from real Singapore retailers.

Quick Example

import httpx

# Search for TVs under $2000 SGD
response = httpx.get(
    "https://api.buywhere.ai/search",
    params={"q": "65 inch TV", "max_price": 2000},
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)

products = response.json()["products"]
for p in products:
    print(f"{p['name']} — ${p['price']} at {p['retailer']}")

MCP Support (Claude Agents)

BuyWhere ships with native MCP (Model Context Protocol) support. If you're building Claude-compatible agents, BuyWhere plugs in directly as an MCP tool — no custom glue code needed.

{
  "mcpServers": {
    "buywhere": {
      "command": "npx",
      "args": ["buywhere-mcp"],
      "env": { "BUYWHERE_API_KEY": "your-key-here" }
    }
  }
}

Who Is This For?

Agent developers building consumer/shopping tools for Singapore & SEA
LangChain/CrewAI/LlamaIndex developers who want grounded product data
MCP developers building Claude agents with real-world data access
AI demo builders who need realistic, live data for showcasing agents

Get Started

Dev docs and API reference: buywhere.ai/developers

Building something cool with it? Drop a comment — happy to discuss agent architectures for shopping use cases.

Build a Singapore Price-Watch Agent with LangGraph and BuyWhere

BuyWhere — Sat, 25 Apr 2026 06:01:37 +0000

Build a Singapore Price-Watch Agent with LangGraph and BuyWhere

In this tutorial, we'll build a simple price-watch agent using LangGraph and BuyWhere's Singapore product catalog API. The agent will monitor product prices and alert when a price drops below a threshold.

Prerequisites

Python 3.11+
LangGraph (pip install langgraph langchain-openai)
BuyWhere API key (free at buywhere.ai/developers)
OpenAI API key

What We're Building

A LangGraph agent that:

Takes a product query and target price
Searches BuyWhere for current Singapore prices
Reports whether the target price is achievable
Loops until the price is found or max retries reached

Step 1: Set Up BuyWhere Tool

import requests
from langchain_core.tools import tool

BUYWHERE_KEY = "your_key_here"

@tool
def search_singapore_prices(query: str) -> dict:
    """Search for current product prices in Singapore. Returns a list of products with prices."""
    response = requests.get(
        "https://api.buywhere.ai/search",
        params={"q": query, "sort": "price_asc", "limit": 10},
        headers={"Authorization": f"Bearer {BUYWHERE_KEY}"}
    )
    data = response.json()
    products = data.get("products", [])

    return {
        "query": query,
        "lowest_price": products[0]["price"] if products else None,
        "currency": "SGD",
        "products": [
            {
                "name": p["name"],
                "price": p["price"],
                "retailer": p["retailer"]
            }
            for p in products[:5]
        ]
    }

Step 2: Define Agent State

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class PriceWatchState(TypedDict):
    messages: Annotated[list, add_messages]
    product_query: str
    target_price: float
    current_lowest_price: float | None
    price_found: bool
    attempts: int

Step 3: Build the Graph

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage

llm = ChatOpenAI(model="gpt-4o-mini").bind_tools([search_singapore_prices])

def search_node(state: PriceWatchState) -> PriceWatchState:
    """Search for current prices."""
    messages = state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response], "attempts": state["attempts"] + 1}

def process_results(state: PriceWatchState) -> PriceWatchState:
    """Process search results and check against target."""
    # Extract tool results from messages
    last_message = state["messages"][-1]

    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
        # Tool was called, results will come back
        return state

    # Extract price from response
    content = last_message.content
    current_price = state.get("current_lowest_price")
    target = state["target_price"]

    price_found = current_price is not None and current_price <= target
    return {"price_found": price_found}

def should_continue(state: PriceWatchState) -> str:
    if state.get("price_found"):
        return "done"
    if state.get("attempts", 0) >= 3:
        return "done"
    return "search"

# Build graph
graph_builder = StateGraph(PriceWatchState)
graph_builder.add_node("search", search_node)
graph_builder.add_node("check", process_results)

graph_builder.set_entry_point("search")
graph_builder.add_edge("search", "check")
graph_builder.add_conditional_edges("check", should_continue, 
    {"done": END, "search": "search"})

graph = graph_builder.compile()

Step 4: Run the Agent

def run_price_watch(product: str, target_price: float):
    initial_state = {
        "messages": [
            SystemMessage(content="You are a Singapore price monitoring agent. Search for product prices using the search tool."),
            HumanMessage(content=f"Find the cheapest '{product}' in Singapore. Target budget: S${target_price}")
        ],
        "product_query": product,
        "target_price": target_price,
        "current_lowest_price": None,
        "price_found": False,
        "attempts": 0
    }

    result = graph.invoke(initial_state)
    return result

# Example usage
result = run_price_watch("iPhone 16 256GB", 1500.0)
print(result["messages"][-1].content)

Sample Output

Found iPhone 16 256GB in Singapore:
- iPhone 16 256GB Blue: S$1,399 at Harvey Norman
- iPhone 16 256GB Black: S$1,399 at Shopee  
- iPhone 16 256GB Natural: S$1,449 at Lazada

Good news! The current lowest price (S$1,399) is below your target of S$1,500.

Going Further

Add email notifications when price drops are detected
Persist state with LangGraph checkpointing for daily monitoring
Expand to track multiple products simultaneously
Add price history tracking

Resources

BuyWhere API docs: buywhere.ai/developers
LangGraph docs: https://langchain-ai.github.io/langgraph/

Add Real-Time Singapore Product Search to Any AI Agent (5-Minute Integration)

BuyWhere — Sat, 25 Apr 2026 05:59:19 +0000

Add Real-Time Singapore Product Search to Any AI Agent (5-Minute Integration)

Building an AI agent that needs to search for products in Singapore? Here is the quickest path to live pricing data.

BuyWhere (https://buywhere.ai) is a product catalog API purpose-built for AI agents. One API call, real pricing from Harvey Norman, Shopee, Lazada, and 10+ other Singapore retailers.

Step 1: Get your API key

Step 2: Test the API

curl "https://api.buywhere.ai/search?q=Samsung+TV" \
  -H "Authorization: Bearer YOUR_API_KEY"

Response:

{
  "query": "Samsung TV",
  "products": [
    {
      "name": "Samsung 55\" 4K Smart TV",
      "price": 899.00,
      "currency": "SGD",
      "retailer": "Harvey Norman",
      "url": "https://...",
      "in_stock": true
    },
    {
      "name": "Samsung Crystal 4K UHD TV 55-inch",
      "price": 849.00,
      "currency": "SGD",
      "retailer": "Shopee",
      "url": "https://...",
      "in_stock": true
    }
  ]
}

Step 3: Add to your agent

OpenAI Agents SDK

from agents import Agent, function_tool
import requests

API_KEY = "your_buywhere_key"

@function_tool
def search_singapore_products(query: str) -> str:
    """Search for products with live prices from Singapore retailers."""
    r = requests.get(
        "https://api.buywhere.ai/search",
        params={"q": query, "limit": 5},
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    products = r.json().get("products", [])
    if not products:
        return "No products found."
    return "\n".join([
        f"{p['name']}: S${p['price']:.2f} at {p['retailer']}"
        for p in products
    ])

shopping_agent = Agent(
    name="Singapore Shopping Assistant",
    instructions="""You help users find products in Singapore at the best prices. 
    Use search_singapore_products to get live pricing data.""",
    tools=[search_singapore_products]
)

LangChain

from langchain.tools import tool

@tool
def search_sg_products(query: str) -> str:
    """Search for products with live Singapore pricing."""
    import requests
    r = requests.get(
        "https://api.buywhere.ai/search",
        params={"q": query},
        headers={"Authorization": "Bearer YOUR_KEY"}
    )
    products = r.json().get("products", [])[:5]
    return "\n".join([f"{p['name']}: S${p['price']} ({p['retailer']})" for p in products])

Claude MCP (Claude Desktop / Continue.dev)

BuyWhere is also available as an MCP server. Add it to your MCP config and any Claude agent can search Singapore products natively.

What it covers

1,000+ products across electronics, home appliances, furniture
Major retailers: Harvey Norman, Shopee, Lazada, Courts, Best Denki
Updated daily: prices are current
Singapore only (for now)

Why not scrape?

Scrapers break constantly. Retailers update their HTML, add bot protection, and change URLs. BuyWhere maintains the data pipeline so you do not have to.

API docs: buywhere.ai/developers

Building AI Agents for Southeast Asia: The Commerce Data Problem

BuyWhere — Sat, 25 Apr 2026 05:55:43 +0000

Building AI Agents for Southeast Asia: The Commerce Data Problem

Southeast Asia is one of the fastest-growing e-commerce markets in the world. Shopee and Lazada dominate. Tokopedia, JD.ID, and dozens of local platforms compete. And increasingly, developers are building AI agents to help consumers navigate all of this.

But there is a gap: where does an AI agent get its product data?

The SEA Commerce Data Landscape

Building a shopping agent for Southeast Asia means dealing with:

Multiple platforms: Shopee, Lazada, Tokopedia, Harvey Norman, Courts, and more
Real-time pricing: prices change constantly, especially during sales
Multi-language product listings: English, Bahasa, Chinese, Thai, Vietnamese
Regional availability: a product available in Singapore may not be in Malaysia

Most developers who try to solve this end up building scrapers. It is understandable — the data is right there on the product pages. But scrapers are fragile, violate ToS, and break constantly.

A Better Approach: Dedicated Commerce APIs

For Singapore specifically, BuyWhere has solved this problem. It is a real-time product catalog API that aggregates pricing from:

Harvey Norman
Shopee Singapore
Lazada Singapore
And 10+ other retailers

One API call. Structured data. Updated daily. No scraping.

curl "https://api.buywhere.ai/search?q=iPhone+16&country=sg" \
  -H "Authorization: Bearer YOUR_KEY"

Response:

{
  "products": [
    {
      "name": "Apple iPhone 16 128GB",
      "price": 1299.00,
      "currency": "SGD",
      "retailer": "Harvey Norman",
      "url": "https://...",
      "in_stock": true
    },
    ...
  ]
}

Building a Singapore Shopping Agent

Here is a minimal LangChain shopping agent using BuyWhere:

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate
import requests

BUYWHERE_KEY = "your_key_here"

@tool
def find_cheapest_in_singapore(product: str) -> str:
    """Find the cheapest price for a product in Singapore."""
    r = requests.get(
        "https://api.buywhere.ai/search",
        params={"q": product, "sort": "price_asc"},
        headers={"Authorization": f"Bearer {BUYWHERE_KEY}"}
    )
    products = r.json().get("products", [])[:3]
    if not products:
        return "No products found."
    lines = [f"{p['name']} — S${p['price']:.2f} at {p['retailer']}" 
             for p in products]
    return "\n".join(lines)

llm = ChatOpenAI(model="gpt-4o-mini")
tools = [find_cheapest_in_singapore]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful Singapore shopping assistant."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

result = executor.invoke({"input": "Find me the cheapest 65-inch TV"})
print(result["output"])

What is Next for SEA Agent Commerce

Singapore is the starting point, but the bigger opportunity is Southeast Asia as a whole. Thailand, Indonesia, Vietnam, Philippines — each has its own dominant platforms and consumer behaviors.

The developers who build the data layer for these markets will have a significant advantage.

BuyWhere developer docs: buywhere.ai/developers

Why AI Agents Need a Product Catalog API (Not a Scraper)

BuyWhere — Sat, 25 Apr 2026 05:55:22 +0000

Why AI Agents Need a Product Catalog API (Not a Scraper)

Every week, another AI agent developer posts about building a shopping assistant. And every week, they hit the same wall: how do you get reliable product data at scale?

The usual answer is: build a scraper. But scrapers break. They get rate-limited. They require maintenance. And for AI agents operating in production, a breaking scraper means a broken agent.

There is a better approach.

The Problem with Scrapers for Agent Commerce

AI agents are different from traditional software. They need:

Reliable, structured data — agents can't parse broken HTML
Real-time pricing — stale prices mislead users
Fast API responses — agents often chain multiple tool calls
No maintenance burden — agents should call tools, not maintain infrastructure

Scrapers fail on all four counts.

What Agents Actually Need: A Product Catalog API

A purpose-built product catalog API solves all of these problems. Instead of scraping, agents call an API endpoint, get structured JSON back, and move on.

For Singapore developers, BuyWhere is exactly this.

# One API call, real product data
import requests

result = requests.get(
    "https://api.buywhere.ai/search",
    params={"q": "laptop", "country": "sg"},
    headers={"Authorization": "Bearer YOUR_KEY"}
)

products = result.json()
# Returns: name, price, retailer, URL, availability

That single call returns live pricing from Harvey Norman, Shopee, Lazada, and 10+ other Singapore retailers.

Using BuyWhere with LangChain

from langchain.tools import tool
import requests

@tool
def search_singapore_products(query: str) -> str:
    """Search for products with live prices from Singapore retailers."""
    response = requests.get(
        "https://api.buywhere.ai/search",
        params={"q": query},
        headers={"Authorization": "Bearer YOUR_KEY"}
    )
    products = response.json()["products"][:5]
    return "\n".join([f"{p['name']} — S${p['price']} at {p['retailer']}" for p in products])

Using with OpenAI Agents SDK

from agents import Agent, function_tool
import requests

@function_tool
def get_singapore_prices(product_name: str) -> str:
    """Get real-time Singapore prices for a product."""
    r = requests.get("https://api.buywhere.ai/search",
                     params={"q": product_name},
                     headers={"Authorization": "Bearer YOUR_KEY"})
    items = r.json().get("products", [])[:3]
    return "\n".join([f"{i['name']}: S${i['price']} ({i['retailer']})" for i in items])

agent = Agent(
    name="Shopping Assistant",
    instructions="Help users find the best prices in Singapore.",
    tools=[get_singapore_prices]
)

MCP Support

If you are building Claude-compatible agents, BuyWhere also supports MCP. No custom code needed — just point your MCP client at the BuyWhere endpoint.

The Bigger Picture

AI agent commerce is happening now. Developers are building agents that compare prices, recommend products, and help users make purchasing decisions. These agents need data infrastructure that matches their reliability requirements.

Product catalog APIs are the answer. Scrapers are a dead end.

Get started with BuyWhere: buywhere.ai/developers

Give Your OpenAI Agent Live Singapore Prices in 5 Minutes

BuyWhere — Sat, 25 Apr 2026 05:43:24 +0000

Give Your OpenAI Agent Live Singapore Prices in 5 Minutes

Most shopping agents either hallucinate prices or scrape pages that break every month.

BuyWhere fixes that: one API call returns real-time prices from Harvey Norman, Shopee, Lazada, and 20+ Singapore retailers. Here's how to wire it into an OpenAI Agents SDK agent in under 5 minutes.

Prerequisites

Python 3.11+
openai-agents SDK
A free BuyWhere API key (grab one at buywhere.ai/dashboard)

Install

pip install openai-agents requests

The Agent

import os
import requests
from agents import Agent, Runner, function_tool

BUYWHERE_API_KEY = os.environ["BUYWHERE_API_KEY"]
BUYWHERE_BASE = "https://api.buywhere.ai"

@function_tool
def search_products(query: str, limit: int = 5) -> dict:
    resp = requests.get(
        f"{BUYWHERE_BASE}/v1/search",
        params={"q": query, "limit": limit},
        headers={"Authorization": f"Bearer {BUYWHERE_API_KEY}"},
        timeout=10
    )
    resp.raise_for_status()
    return resp.json()

@function_tool
def get_product_prices(product_id: str) -> dict:
    resp = requests.get(
        f"{BUYWHERE_BASE}/v1/products/{product_id}/prices",
        headers={"Authorization": f"Bearer {BUYWHERE_API_KEY}"},
        timeout=10
    )
    resp.raise_for_status()
    return resp.json()

shopping_agent = Agent(
    name="Singapore Shopping Agent",
    instructions=(
        "You are a shopping assistant for Singapore. "
        "When asked about a product, use search_products to find live prices. "
        "Always include the retailer name and exact price."
    ),
    tools=[search_products, get_product_prices]
)

import asyncio

async def main():
    result = await Runner.run(
        shopping_agent,
        "Where's the cheapest Samsung Galaxy S25 in Singapore right now?"
    )
    print(result.final_output)

asyncio.run(main())

What You Get

When you run this, the agent will:

Call search_products with "Samsung Galaxy S25"
Get live prices from Shopee, Lazada, Harvey Norman, and others
Return a grounded answer with actual current prices — no hallucinations

Sample output:

The Samsung Galaxy S25 (256GB) is currently cheapest on Shopee at S$1,099,
compared to S$1,199 at Harvey Norman and S$1,149 on Lazada.

Why This Beats Scraping

No brittle selectors — retailers change their HTML constantly
Live data — prices update throughout the day
Structured output — product IDs, images, specs alongside price
Rate-limit safe — one API call, not 20 page loads

Using BuyWhere MCP Instead

If you're building with Claude or any MCP-compatible tool:

{
  "mcpServers": {
    "buywhere": {
      "command": "npx",
      "args": ["-y", "buywhere-mcp"],
      "env": {
        "BUYWHERE_API_KEY": "your_api_key_here"
      }
    }
  }
}

The MCP server exposes search_products, get_product, get_price, and compare_prices as native MCP tools. A remote Streamable HTTP endpoint is also available at https://api.buywhere.ai/mcp — now listed on Smithery.

Next Steps

Developer docs — full API reference
buywhere-mcp on npm — MCP server package
API key — free tier available

Questions? Drop a comment or email surf@buywhere.ai.

BuyWhere: Real-time Singapore Product Catalog API for AI Agents

BuyWhere — Sat, 25 Apr 2026 05:28:53 +0000

BuyWhere: Real-time Singapore Product Catalog API for AI Agents

If you're building AI agents that need to answer shopping questions — "Where can I buy a Samsung TV for the cheapest price in Singapore?" — you've probably run into the scraping problem.

Scraping e-commerce sites is fragile, slow, and legally murky. Most APIs that exist are either expensive, US-only, or not updated frequently enough for real pricing data.

Introducing BuyWhere

BuyWhere is a product catalog API built specifically for AI agents operating in Singapore (and Southeast Asia). With a single API call, your agent can search live pricing across:

Harvey Norman — Singapore's largest electronics retailer
Shopee — Southeast Asia's largest e-commerce platform
Lazada — Alibaba's SEA marketplace
And 1,000+ products updated daily

How It Works

import requests

# One API call to get live Singapore pricing
response = requests.get(
    "https://api.buywhere.ai/search",
    params={"q": "Samsung 65 inch TV", "region": "sg"},
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)

results = response.json()
# Returns: [{"product": "Samsung QN65", "price": 1299, "store": "Harvey Norman", "url": "..."}]

MCP Support (Claude, OpenAI Agents, LangChain)

BuyWhere ships with native MCP (Model Context Protocol) support, so you can plug it into:

Claude — add BuyWhere as an MCP tool in your Claude agent
OpenAI Agents SDK — register as a function tool
LangChain — use as a LangChain tool

# With LangChain
from langchain.tools import StructuredTool

buy_where_tool = StructuredTool.from_function(
    func=buywhere_search,
    name="buywhere_search",
    description="Search live Singapore product prices across Harvey Norman, Shopee, Lazada"
)

Why Agents Need This

Shopping is one of the most common agent use cases, but most agents either:

Hallucinate prices (bad)
Try to scrape and fail (unreliable)
Use outdated product data (misleading)

BuyWhere solves this with a clean, agent-native API that returns structured data your agent can reason about.

Get Started

API docs and free tier available at: buywhere.ai/developers

Building something with it? I'd love to hear what you're working on in the comments.

Built in Singapore, for agents operating in Southeast Asia.