Real-time cross-border price comparison with MCP

Shoppers in Singapore know the drill: check Shopee, check Lazada, check Amazon.sg, maybe check a local retailer — all for the same product. Now imagine scaling that to 9 countries, 11 million products, and getting the answer in one query instead of 30 browser tabs.

That is exactly what the BuyWhere MCP server does. This post walks through a real example: finding the cheapest Sony WH-1000XM5 across Singapore, the US, and Japan in under three seconds.

Why cross-border price comparison matters

Cross-border shopping in Singapore is massive. Consumers routinely check whether electronics, beauty products, and household goods are cheaper on Amazon US, Amazon Japan, or a local SG platform before pulling the trigger.

The problem is that each marketplace has its own search, its own currency, its own shipping logic, and its own API — or no API at all. Doing this manually takes 15-20 minutes per product. With MCP, it takes one function call.

What the BuyWhere MCP server exposes

The BuyWhere MCP server exposes a single products_search tool that accepts:

• 
  query — product name or brand


• 
  country — country code (sg, us, jp, gb, etc.)


• 
  limit — results per page (default 10)


• 
  page — pagination

The response includes merchant name, price, currency, product URL, and a BuyWhere deep-link. You can call it from any MCP-compatible client: Claude Desktop, Cursor, VS Code with the MCP extension, or a plain Python script.

Real example: Sony WH-1000XM5 across 3 countries

Here is what a cross-border query looks like in Python:

import asyncio

from mcp import ClientSession, StdioServerParameters

from mcp.client.stdio import stdio_client



async def compare_across_countries():

    server_params = StdioServerParameters(

        command="npx",

        args=["-y", "@buywhere/mcp-server"]

    )



    async with stdio_client(server_params) as (read, write):

        async with ClientSession(read, write) as session:

            await session.initialize()



            countries = ["sg", "us", "jp"]

            results = {}



            for country in countries:

                result = await session.call_tool(

                    "products_search",

                    {"query": "Sony WH-1000XM5", "country": country, "limit": 3}

                )

                results[country] = result.content



            return results



prices = asyncio.run(compare_across_countries())

The response gives you structured product data with prices, merchants, and direct URLs. You can feed this directly into a comparison table, a price-drop alert, or a ReAct agent decision loop.

Building a comparison agent with LangChain

Here is a minimal LangChain tool-calling agent that searches across multiple countries and picks the cheapest option:

from langchain.agents import AgentExecutor, create_openai_tools_agent

from langchain.tools import tool

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate



@tool

def search_product(query: str, country: str) -> str:

    """Search for a product in a given country's marketplaces."""

    # Calls BuyWhere MCP server under the hood

    ...



tools = [search_product]

prompt = ChatPromptTemplate.from_messages([

    ("system", "You are a cross-border price comparison assistant. "

               "Search across sg, us, jp, gb, and de markets. "

               "Present results as a ranked table."),

    ("human", "{input}"),

    ("placeholder", "{agent_scratchpad}"),

])



llm = ChatOpenAI(model="gpt-4o")

agent = create_openai_tools_agent(llm, tools, prompt)

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)



result = agent_executor.invoke({

    "input": "Find the cheapest Sony WH-1000XM5 across SG, US, and Japan"

})

print(result["output"])

Why MCP is the right interface for this

Before MCP, integrating product search into an AI agent meant:

• Writing a custom API client for each marketplace


• Handling authentication and rate limits per provider


• Building a unified schema layer


• Updating when any marketplace changed their API

With MCP, the BuyWhere server handles all of that. Your agent only needs to speak the MCP protocol — one client, one schema, one integration point.

Try it yourself

1. Install the server: npx @buywhere/mcp-server
   


2. Connect from Claude Desktop, Cursor, or your own Python client


3. Start comparing prices across 9 countries in real time

The BuyWhere MCP server covers 11 million products across Singapore, US, Japan, UK, Germany, Australia, India, UAE, and Canada — all through one MCP tool.

This is the second post in a 4-part series on building AI shopping agents with MCP. Follow BuyWhere on dev.to for the next post: Building an AI shopping agent that actually buys things.