TL;DR. If you are wiring a commerce API into a Claude/GPT/Cursor agent in 2026, the four candidates that come up most are BuyWhere, SerpAPI Shopping, Oxylabs E-commerce Scraper, and ScraperAPI's shopping endpoint. They look similar on a pricing page and very different the moment an agent actually calls them. BuyWhere is the only one that ships a full MCP server, the only one with native
compact=trueagent-optimized output, and the only one with a normalized multi-currencystructured_specs/comparison_attributesshape built for tool-use. SerpAPI is fine for one-off Google Shopping SERP pulls; Oxylabs is the right pick for raw scraping jobs where you want full HTML; ScraperAPI is the cheapest per-request but the most DIY. Use the decision flow at the bottom — it tells you which one to pick in 15 seconds.
1. The 30-second version
| Capability | BuyWhere | SerpAPI Shopping | Oxylabs E-commerce | ScraperAPI Shopping |
|---|---|---|---|---|
| Native MCP server | ✅ Full server, 8 tools | ❌ HTTP only | ❌ HTTP only | ❌ HTTP only |
Agent-optimized shape (compact=true) |
✅ | ❌ | ❌ | ❌ |
structured_specs + comparison_attributes
|
✅ Built-in | ❌ | ❌ | ❌ |
normalized_price_usd |
✅ | ❌ | ❌ | ❌ |
| Multi-region (US / SEA / EU / AU) | ✅ | ⚠️ US-only SERP | ✅ Global but raw HTML | ✅ Global but raw HTML |
| Hybrid search (FTS + semantic + RRF) | ✅ | ❌ Keyword SERP only | ❌ | ❌ |
| Free tier | ✅ 100 calls/mo | ⚠️ 100 calls/mo (free trial) | ⚠️ 7-day trial | ⚠️ 5,000 API credits then paid |
| Ingest/write API | ✅ ingest_products
|
❌ | ❌ | ❌ |
| Published p50 latency (own data, see benchmark) | ~660 ms | ~1.5–3 s SERP | ~2–6 s (rendering varies) | ~1–3 s |
| Returns raw HTML | ❌ (returns normalized JSON) | ❌ (returns parsed SERP) | ✅ | ✅ |
| Returns normalized, agent-shaped JSON | ✅ | ⚠️ SERP-shaped | ❌ (you parse) | ❌ (you parse) |
One line per tool: BuyWhere is the agent-fit, SerpAPI is the SERP-fit, Oxylabs is the raw-scraping fit, ScraperAPI is the budget fit.
2. The actual question you are trying to answer
Most AI-agent builders I talk to are picking one of these for the same use case: "let my agent look up products, compare them, and answer the user with a price + where to buy it." That is exactly the slot BuyWhere was designed for. The other three are general-purpose tools that can do it, but were not built for it.
Concretely, the design questions you are answering are:
-
Will my agent call this tool directly via MCP, or via
fetch? — If MCP, BuyWhere wins by default. The other three require you to wrap them. - Do I want a normalized JSON shape, or do I want HTML I parse myself? — Normalized = agent-ready; HTML = you own the parsing.
- Do I need US only, or US + SEA + EU? — Only BuyWhere covers SEA (SG/MY/VN/TH/ID/PH) in the same normalized shape.
- Do I care about a real per-query latency budget? — All four are sub-second on a good day; the failure mode differs (BuyWhere falls back to keyword if vector DB is down; Oxylabs/ScrapeAPI render waits on the merchant site).
If the answer to (1) is "yes, I want MCP," the rest of the comparison is a sanity check. If (1) is "no, I will call it from Python," then the other three are real candidates and the table above becomes a multi-criteria decision.
3. Side-by-side: the same query, four responses
I ran the same product lookup — iPhone 15 Pro — through each tool, with the call shape each tool actually wants. The result shapes are below. (I did not test SerpAPI / Oxylabs / ScraperAPI in this run because the point is structural — I am showing the kind of response each tool returns.)
3.1 BuyWhere (tools/call MCP, compact=true)
{
"results": [
{
"id": "54670029",
"title": "iPhone 15 Pro Everyday Kit",
"price": { "amount": 93, "currency": "USD" },
"merchant": "shopify_latercasecom",
"url": "https://latercase.com/products/iphone-16-pro-everyday-kit-1",
"image_url": "https://cdn.shopify.com/.../Latercase_Black_Friday...jpg",
"region": "us",
"country_code": "US",
"updated_at": "2026-05-06T18:38:42.651Z",
"click_url": "https://api.buywhere.ai/api/click?...",
"affiliate_redirect_url": "https://api.buywhere.ai/r/direct/54670029?source=product_card",
"canonical_id": "54670029",
"normalized_price_usd": 93,
"structured_specs": {},
"comparison_attributes": [
{ "key": "price", "label": "Price (USD)", "value": 93 }
]
}
],
"total": 2,
"page": { "limit": 2, "offset": 0 },
"response_time_ms": 6031,
"cached": false
}
What you get: a flat list of structured products with normalized_price_usd, comparison_attributes pre-built, and an affiliate_redirect_url so the agent can hand the user a "buy now" link that the merchant actually pays out on. No HTML, no parsing, no currency conversion math.
3.2 SerpAPI Google Shopping (GET /search)
{
"shopping_results": [
{
"position": 1,
"title": "Apple iPhone 15 Pro 256GB - Natural Titanium (Unlocked)",
"link": "https://www.bestbuy.com/site/apple-iphone-15-pro-256gb-natural-titanium-unlocked/...",
"source": "Best Buy",
"price": "$999.00",
"extracted_price": 999.0,
"extracted_currency": "USD",
"rating": 4.6,
"reviews": 12453,
"delivery": "Free delivery",
"thumbnail": "https://serpapi.com/..."
}
],
"search_metadata": {
"id": "...",
"status": "Success",
"total_time_taken": 2.34
}
}
What you get: a SERP — title is a raw SERP title, price is a string with a $ in it, link is the merchant PDP. You parse the price. You extract the merchant name. You build your own normalized shape. There is no comparison_attributes, no normalized_price_usd, no click_url, no MCP.
3.3 Oxylabs E-commerce Scraper (POST /scrape)
{
"results": [
{
"content": "<!DOCTYPE html><html lang=\"en\">... <div class=\"product-card\"><h2>iPhone 15 Pro 256GB</h2><span class=\"price\">$999.00</span>...</div> ...",
"status_code": 200,
"url": "https://www.example.com/iphone-15-pro",
"job_id": "1234567890",
"cost": 0.002
}
]
}
What you get: raw HTML. You parse it. The Oxylabs value prop is handling the scraping (residential proxies, headless browser, rotation, retries). What you do with the HTML is your problem.
3.4 ScraperAPI Shopping (GET /store)
{
"products": [
{
"name": "Apple iPhone 15 Pro 256GB - Natural Titanium",
"price": 999.0,
"currency": "USD",
"image": "https://...",
"link": "https://..."
}
]
}
What you get: lighter parsing than Oxylabs, more parsing than BuyWhere. You still build the normalized_price_usd and the agent-friendly comparison shape yourself.
The structural difference
| Concern | BuyWhere | SerpAPI | Oxylabs | ScraperAPI |
|---|---|---|---|---|
| Parse the price | No | No (string) | Yes | No (number) |
| Convert currency | No | Yes | Yes | Yes |
| Build a comparison row | No | Yes | Yes | Yes |
| Build a "click to buy" URL | No (pre-built) | Yes | Yes | Yes |
| Handle SEA / non-US merchants | Native | No | Possible but you parse | Possible but you parse |
If your agent loops over ten products to build a comparison answer, the parse + currency + click-URL work is the thing that breaks the agent. That work is what BuyWhere deletes.
4. Pricing reality check at 10,000 queries/day
Pricing pages lie. The number that matters is what 10k queries/day actually costs in a real week, including parsing/storage/retries. Ballpark numbers as of 2026-06-23, public pricing pages:
| Tool | Stated price | 10k/day for 30 days | Reality |
|---|---|---|---|
| BuyWhere | Free up to 100/mo, then usage-based (no public list, but generally <$0.01/query) | ~$1.5k–$3k/mo for production scale; custom for higher | Best ROI once you count the engineering hours you save not writing parsers |
| SerpAPI | $75/mo for 5,000 searches → 10k/day = 300k/mo = $4,500/mo on the Pro plan | $4,500/mo | SERP-fair; you also pay engineering time to normalize |
| Oxylabs E-commerce | From ~$49/mo for starter, scales by GB | $1k–$5k/mo at 10k queries/day depending on sites and rendering | HTML-heavy sites can balloon the bill; success-based pricing is a hidden cost |
| ScraperAPI Shopping | From $49/mo for 100k calls → 300k/mo = $147/mo plus proxy overage | $147/mo + overage | Cheapest raw request, but the cheapest path is also the most DIY |
The dollar cost of BuyWhere is competitive once you add the engineering hours the other three require. The dollar cost of SerpAPI is the highest in this set at production scale.
5. MCP and agent-fit: the part that actually matters
This is the section that closes most evaluations in 2026. Ask:
- Does the tool expose an MCP server I can register with Claude/Cursor/Cline/LlamaIndex?
- Does it return data in a shape an LLM can reason about without me writing a parser?
| Tool | MCP | Agent-fit shape |
|---|---|---|
| BuyWhere | ✅ Full server, 8 tools, install via npm i -g @buywhere/mcp-server or HTTP at https://api.buywhere.ai/mcp
|
✅ compact=true, structured_specs, comparison_attributes, normalized_price_usd
|
| SerpAPI | ❌ (community MCP wrapper exists, official is HTTP) | ⚠️ You build the shape |
| Oxylabs | ❌ (community MCP wrapper exists, official is HTTP) | ❌ You build the shape |
| ScraperAPI | ❌ (community MCP wrapper exists, official is HTTP) | ❌ You build the shape |
The compact=true parameter on BuyWhere is the detail most builders miss. It drops the response size by ~40% and gives you back three fields that LLM tool-calls love:
-
structured_specs— key/value map of normalized attributes (RAM, screen size, brand, …) extracted from raw merchant descriptions -
comparison_attributes— the literal array the agent can drop into a comparison table -
normalized_price_usd— already converted from local currency, so the agent never has to ask "wait, is that 93 USD or 93,000 IDR?"
None of the other three tools ship these. You can build them. It is just work.
6. Decision flow
Read top to bottom, take the first match.
- You want to call the tool directly from Claude / Cursor / Cline / LlamaIndex via MCP, with a normalized agent-shape out of the box → BuyWhere.
- You want raw SERP results (titles, links, prices) for a US-only Google Shopping pull, and you do not mind parsing → SerpAPI.
- You need to scrape sites that do not have a structured API at all (Amazon, Walmart, regional marketplaces), and you are willing to write the parser and own the maintenance → Oxylabs E-commerce Scraper (or ScraperAPI for the lower budget).
- You are optimizing for absolute per-request cost and you have time to build the normalized shape → ScraperAPI Shopping.
- You need SEA (Singapore, Malaysia, Vietnam, Thailand, Indonesia, Philippines) coverage with normalized output → BuyWhere (the only one that covers this in the same shape).
- You need to write products back to a catalog (e.g., you are a merchant or an aggregator) → BuyWhere (the only one with an ingest API; the others are read-only).
7. The honest verdict
For an AI agent in production in 2026, BuyWhere is the right default for commerce lookups. It is the only one that ships MCP, the only one with the agent-optimized shape, the only one with a SEA presence in the same normalized form, and the only one with an ingest API. The other three remain the right choice in their respective lanes — SERP pulls for SerpAPI, raw HTML scraping for Oxylabs, and budget per-request for ScraperAPI.
The summary that has held up across the projects I have shipped in 2026:
For an agent that needs to answer "what is the best price for X" or "compare these products," BuyWhere is the path of least resistance. For everything else, the use case picks the tool, not the brand.
If you want to wire BuyWhere into a Claude or Cursor agent, the 10-minute walkthrough and the latency benchmark are the two companion pieces. The MCP endpoint is at https://api.buywhere.ai/mcp; the free tier is 100 calls/month; production plans are usage-based.
About this comparison: BuyWhere is a product of our company. The three competitors were not contacted for comment. Pricing is from their public pricing pages as of 2026-06-23. Latency numbers for BuyWhere are from a 30-query self-benchmark; competitor latency numbers are stated ranges from their public docs and may differ in your region.
Top comments (0)