An AI shopping agent is software that searches for products, compares prices and stock, and fills a cart or places an order for a person. It reaches a store in one of three ways: through a commerce protocol the merchant publishes, through the buyer's own browser, or through a browser or HTTP client that the agent's developer runs in the cloud. Retail blocks mostly land on the third route, and they come from three things: the IP address, the session the agent carries, and the country that IP places it in.
We measured that on November 10, 2026. From one datacenter server in Germany, we loaded 42 retail homepages with a plain HTTP client and with headless Chromium. Only 14 to 16 loaded as a normal US storefront. Eleven or twelve returned an "Access Denied" page, five or six showed a bot check, and seven or eight either sent us to another country's store or refused service outside the US. In the same test, eight of the 42 stores published a machine-readable commerce profile. All seven of those on Shopify answered a structured catalog call with prices and per-size stock in about half a second, with no bot check.
So the first question for anyone building an AI shopping agent is which route the store supports. The network questions come after that.
Three ways an AI shopping agent reaches a store
| Route | Examples | Whose IP the store sees | Where session state lives | Typical failure |
|---|---|---|---|---|
| Commerce protocol | Google's UCP checkout in AI Mode and Gemini, Shopify's UCP MCP endpoint | The platform's servers, with the buyer's IP passed as a data field | A cart ID returned by the API | Missing agent profile, merchant not enrolled |
| Buyer's own browser | Perplexity Comet, Chrome with Gemini, Shopify's WebMCP checkout | The buyer's home connection | The buyer's cookies and logins | Behavior checks, terms-of-service disputes |
| Developer-run browser or fetcher | Browser Use, Playwright, a requests-based tool | Whatever server or proxy you run it from | A cookie jar you have to manage | IP reputation, geo redirects, challenges |
The protocol route is newest. Google launched the Universal Commerce Protocol on January 11, 2026, co-developed with Shopify, Etsy, Wayfair, Target, and Walmart. Its checkout runs inside Google's own surfaces, and the retailer remains the merchant of record. It started with eligible US retailers and expanded to Canada on November 4, 2026. A store that supports UCP publishes a business profile at /.well-known/ucp that lists its endpoints and transports (REST, MCP, A2A, or embedded). OpenAI tried a different model: Instant Checkout launched in ChatGPT in September 2025, and in March 2026 OpenAI said merchants could use their own checkout while it focused on product discovery.
The buyer's-browser route is what most consumers use. Here the store sees the buyer's own IP and cookies, so a better proxy fixes nothing. Our agentic browser guide covers how local and cloud-hosted agent browsers differ. Shopify extended this route on September 28, 2026, when it opened checkout to browser-based agents through WebMCP. Agents can read and fill the checkout screen, and they place the order only after the buyer approves it.
The developer-run route is what you get when you build a shopping agent with Browser Use, Playwright MCP, or a fetch tool and host it on a cloud server. That is where the rest of this guide spends its time, because it's the route where the IP, the session, and the location are your problem.
Test: 42 retailers, one datacenter IP
Setup
- Origin. One Hetzner server in Germany with no proxy. That's what a self-hosted shopping agent looks like before anyone adds network configuration.
- Sites. 32 large US retailers, from Amazon, Walmart, and Target to Home Depot, Sephora, and GameStop, plus 10 direct-to-consumer brands. Seven of the brands run on Shopify.
- HTTP client. Python
requests2.32.5 with a Chrome 155User-Agent,Accept, andAccept-Language: en-US. One homepage request per site. - Browser. Playwright 1.60 driving chrome-headless-shell 148.0.7778.96 with an
en-USlocale. Each homepage got 6 seconds afterDOMContentLoaded, and we recorded the status, title, visible text, and cookies. We ran the browser pass twice. Every site gave the same outcome both times. - Protocol probe. A
GET /.well-known/ucpon each site.
Each site got two to four requests in total. This was a snapshot of first contact, not a load test.
What the homepages returned

| Outcome | HTTP client | Headless Chromium | Sites |
|---|---|---|---|
| Normal US storefront | 16 | 14 | Walmart, Target, Costco, Ulta, Walgreens, GameStop, Allbirds, Brooklinen, and others |
| Sent to another country's store | 4 | 5 | Nike (/de/), Glossier and SKIMS (/en-de), Kylie Cosmetics, plus Best Buy's country picker in the browser |
| Refused outside the US | 3 | 3 | CVS, Dick's Sporting Goods (451), Foot Locker |
| "Access Denied" or block page | 11 | 12 | Home Depot, Lowe's, Macy's, Kohl's, Sephora, Gap, Zara, Adidas, eBay, Etsy, IKEA, plus Chewy in the browser |
| Challenge or bot check | 5 | 6 | Newegg and B&H (Cloudflare), Bombas (Vercel); see the swaps below |
| Timeout or connection error | 3 | 2 | Kroger, REI, plus Best Buy for the HTTP client |
Four results are worth more than the totals.
The status code is not the verdict. Lowe's returned HTTP 200 with an Akamai "Access Denied" page to both clients. An agent that treats every 200 as success reads a block page as the store's homepage. Check the title and body for block markers before passing a page to the model. The 403 Forbidden guide lists the common ones.
A real browser did worse on three sites. The HTTP client got Wayfair's full 1.05 MB homepage. The browser got a HUMAN "Press & Hold" challenge with a 429. Sam's Club served the HTTP client its homepage but sent the browser to /are-you-human, and Nordstrom sent the browser to a "We've noticed some unusual activity" page. On those sites the HTTP client never ran the bot-detection script. The browser ran it and was flagged. A headless shell on a datacenter IP fails several of the checks those scripts make. Amazon went the other way: it gave the HTTP client a 202 and a 2 KB page asking it to enable JavaScript to prove it wasn't a robot, and let the browser through.
A 429 was not always a rate limit. Bombas returned 429 from a Vercel Security Checkpoint, and Chewy returned 429 to the HTTP client, both on the first request of the session. A real rate limit needs a request count to exceed. These were bot checks that happen to use the "Too Many Requests" code, so backing off and retrying won't clear them. Our HTTP 429 guide gives the quick test: if a slower run succeeds, it's a rate limit, and a request that fails at any speed is an access block.
Geography failed at least as many sessions as challenges did. Seven sites moved the browser to another country's storefront or refused service outside the US, and Best Buy showed it a country picker. CVS returned a page saying it "is not available to customers or patients who are located outside of the United States." For an agent comparing prices, a German storefront isn't a block. It's a wrong answer delivered with a 200.
The bot-management cookies show who was screening each site. HUMAN (_px*) appeared on Walmart, Target, Sam's Club, and Wayfair. Akamai (_abck, bm_sz) appeared on Nike, Best Buy, and Walgreens, Kasada on Costco and Nike, DataDome on Etsy, and Cloudflare's __cf_bm on most of the Shopify stores. Ten of the twelve hard blocks set no vendor cookie at all, because the edge refused the request before a detection script could run. Those decisions were made from the request alone: the IP, the TLS handshake, and the headers.
The protocol route: what a structured store call looks like
Eight of the 42 sites published a UCP business profile. One was Chewy, with a REST endpoint. The other seven were Shopify stores (Allbirds, Glossier, SKIMS, Brooklinen, Fashion Nova, ColourPop, and Kylie Cosmetics), each pointing to an MCP endpoint at {shop}.myshopify.com/api/ucp/mcp. Target, Walmart, Etsy, and Wayfair helped write the protocol but returned 404 on the path. That doesn't rule out UCP support, because Google onboards checkout merchants through Merchant Center. Another 19 sites blocked, errored, or timed out on the request, so the survey can't say whether they publish one.
Chewy is the clearest case. Its homepage turned away both of our clients, yet /.well-known/ucp returned its JSON profile to the Chrome User-Agent and to a descriptive one (shopping-agent-test/1.0 plus a URL). Only the default python-requests/2.32.5 string got a 403.
Shopify moved its storefront catalog and cart tools off /api/mcp to the UCP endpoint, as its migration page explains. On Allbirds, the UCP endpoint listed 16 tools, including search_catalog, get_product, create_cart, update_cart, the checkout tools, and ask_business. A few details from calling it:
- You need an agent profile. A call without one returned HTTP
422with JSON-RPC error-32001, "UCP discovery failed", and the detail "Unable to fetch agent profile: Missing profile uri." Shopify's agent profile docs put the profile URL inmeta.ucp-agent.profileand publish sample profiles for testing. Over plain HTTP, the UCP spec uses aUCP-Agentheader instead. - The tool list is heavy.
tools/listreturned 220 KB of schemas. Load only the tools your agent needs into the model's context, not the whole list. - Sold-out items are hidden by default. The catalog filter
availabledefaults totrue. Askingget_productfor a sold-out size returned no variant at all. With"filters": {"available": false}, the same call returned the variant marked unavailable. A stock checker that skips this reads "sold out" as "doesn't exist." - The buyer's IP is a field, not your egress. The catalog tools accept
signals["dev.ucp.buyer_ip"]andsignals["dev.ucp.user_agent"], so the platform passes on who the buyer is instead of relying on its own server address.

Size matters when an agent checks the same products every day. For one Allbirds shoe, the HTML product page was 733 KB and took 545 ms. That's the document alone, before scripts and images. search_catalog returned three matching products with every size's price and stock in 66.5 KB and 343–349 ms, half of it the same JSON repeated once as text and once as structuredContent. Across the seven Shopify stores, a three-product search took 333–504 ms and returned 34–138 KB. Shopify's older /products/<handle>.js endpoint returned the same per-size availability in 8.1 KB.
This script finds a store's MCP endpoint from its profile and prints price and stock for each size:
import sys
import requests
# Shopify's sample agent profile, fine for testing. Host your own in production.
PROFILE = "https://shopify.dev/ucp/agent-profiles/2026-08-25/valid-with-capabilities.json"
# Name your agent. Some stores refuse the default python-requests User-Agent.
HEADERS = {"User-Agent": "example-shopping-agent/1.0 (+https://example.com/agent)"}
# Amounts are in minor units: cents for USD, but whole yen for JPY.
# These ISO 4217 currencies have no minor unit, so they aren't divided by 100.
ZERO_DECIMAL = {"CLP", "ISK", "JPY", "KRW", "PYG", "UGX", "VND", "XAF", "XOF"}
def mcp_endpoint(store):
profile = requests.get(f"https://{store}/.well-known/ucp", headers=HEADERS, timeout=15)
profile.raise_for_status()
for service in profile.json()["ucp"]["services"].get("dev.ucp.shopping", []):
if service["transport"] == "mcp":
return service["endpoint"]
raise RuntimeError(f"{store} has no UCP MCP endpoint")
def search(endpoint, query, country):
body = {
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "search_catalog",
"arguments": {
"meta": {"ucp-agent": {"profile": PROFILE}},
"catalog": {
"query": query,
"context": {"address_country": country},
# The default (true) hides sold-out items. A stock check needs them.
"filters": {"available": False},
"pagination": {"limit": 3},
},
},
},
}
reply = requests.post(endpoint, json=body, headers=HEADERS, timeout=30).json()
if "error" in reply:
raise RuntimeError(reply["error"]["message"])
return reply["result"]["structuredContent"]["products"]
def format_price(price):
if price["currency"] in ZERO_DECIMAL:
return f"{price['amount']} {price['currency']}"
return f"{price['amount'] / 100:.2f} {price['currency']}"
store, query, country = sys.argv[1], sys.argv[2], sys.argv[3]
for product in search(mcp_endpoint(store), query, country):
print(product["title"])
for variant in product["variants"]:
status = "in stock" if variant["availability"]["available"] else "sold out"
print(f" {variant['title']}: {format_price(variant['price'])}, {status}")
Running python ucp_stock.py www.allbirds.com "wool runners" US printed three products with every size. The first lines:
Women's Wool Runner - Natural Black (Black Sole)
5: 33.00 USD, in stock
6: 33.00 USD, sold out
7: 33.00 USD, sold out
...
Against Chewy it raises "has no UCP MCP endpoint", because Chewy offers REST only. Against Target it raises a 404.
Sessions: where a shopping agent's state lives
A shopping session carries more than a cart. We tested three layers of it.
The cart. On a Shopify storefront, the cart lives in a cart cookie. We added a shoe through /cart/add.js. A fresh session with no cookies saw an empty cart. A third session holding only the cart cookie saw the shoe. The UCP route returns the cart as an ID instead: create_cart gave back gid://shopify/Cart/<token>?key=<key>, valid for 30 days, plus a continue_url for handing checkout to the buyer. A fresh client with no cookies read the same cart through get_cart. Both carts are keyed by a token the agent carries, not by the connection. (We emptied and canceled both afterwards.)
The market. This is the layer that went wrong. Glossier's product page, fetched from Germany, redirected to /en-de/, priced the balm in euros, and set two cookies: localization=DE and cart_currency=EUR. Any later request that sends those cookies carries the German market with it. The UCP endpoint treats the market as a parameter instead. From the same German IP, a search with no context returned the balm at 16.00 USD. With "address_country": "DE" it returned 21.00 EUR. SKIMS behaved the same way: 54.00 USD by default, 68.00 EUR for Germany.
The bot-management state. Cloudflare's cookie reference says __cf_bm "contains information related to the calculation of Cloudflare's proprietary bot score," is generated separately for each site, and expires after 30 minutes of inactivity. Akamai's _abck, HUMAN's _px3, and DataDome's datadome cookie play the same role on other stores. These cookies record what the vendor learned about the session, and an agent that sheds them by switching identities starts the screening over.
We couldn't switch IPs mid-session from one server, so we didn't measure what an IP change does to each vendor's score. The cart test shows what's left: on Shopify, the cart survives anything that keeps its cookie or ID. The location the store inferred from the first request, and the bot score the session has built up, are what you risk when the exit IP changes partway through.
For a developer-run AI shopping agent, that gives four rules:
- One exit IP per buyer session, from the first page view to the checkout handoff. Rotating between search and cart is how an agent shows up from three cities in five minutes.
- One cookie jar per buyer. Never share a browser context between users, and never discard the jar between steps of the same task.
- Set the market on the first request. Send the first request from the buyer's country, or pass
address_countryandcurrencywhere the store accepts them. Check the currency in the first response before going further. - Hand checkout back to the buyer. UCP's
continue_urland Shopify's WebMCP checkout both assume a person approves the order. Keep that step human.
Our sticky vs rotating proxies guide covers session lengths on residential gateways, if you need sticky sessions instead of static IPs.
Price and stock checks: why shopping agents get rate-limited
Price-comparison and restock agents are monitors with a model attached. They hit the same few product URLs over and over, and that's the traffic pattern retail rate limits are built to catch. Three habits keep that traffic small:
- Use the cheapest source that has the answer. In our test, a structured endpoint carried the same per-size stock as a 733 KB page in 8 to 66 KB. Our price monitoring pipeline and competitor price scraping guides cover structured data sources and change detection.
- Separate polling from reasoning. A fixed scheduler should fetch and diff. The model only needs to see what changed. An agent that "checks if it's back in stock" by rereading the whole page every turn spends tokens and requests on nothing.
- Pace per site and per IP. Our delay calculator turns a monitor delay and SKU count into the number of proxies a retail monitor needs, using per-site rest times for Target and Amazon. When the answer is more proxies than the job is worth, raise the delay instead.
When a store refuses automated buying outright, respect that. Drop limits, queues, and per-customer purchase caps exist to share stock among buyers, and a proxy shouldn't be used to get around them. Our sneaker proxy guide covers how retail bot operators size tasks and monitors.
Which IP fits an AI shopping agent
Proxies only matter on the developer-run route. On the protocol route the platform owns the network, and on the buyer's-browser route the buyer does.
| Job | Fits | Why |
|---|---|---|
| Long buyer sessions, logged-in accounts, cart to checkout handoff | Static ISP proxies in the buyer's country | One address for the whole session, ISP-registered rather than cloud-hosted, and stable enough for a partner to allowlist |
| Price and stock comparison across many stores or countries | Rotating residential proxies, country-targeted | Spreads read-only checks and gets each market's real storefront |
| Stores with a UCP or other API route | No proxy for discovery | The protocol takes country as a parameter, and our datacenter IP got answers with no bot check |
Our ISP vs residential guide compares the two in more depth.
The geo redirects keyed on location, so an IP in the buyer's country addresses those directly. The edge refusals are less clear-cut. Two clients with different TLS stacks and headers were refused at the same sites, which points to the datacenter address as the input they shared. But we only tested from one datacenter IP, so we didn't confirm that a residential or ISP IP clears those refusals. And an IP change won't touch the three sites where headless Chromium was challenged and a plain HTTP client wasn't. Those came from the browser itself. How websites detect AI agents goes through the TLS, header, and fingerprint layers that a residential IP leaves unchanged. Our proxies for AI agents guide covers proxy setup for Browser Use and Playwright.
Identify your shopping agent
Payment networks and CDNs are building ways for stores to recognize agents instead of blocking them blind. Visa's Trusted Agent Protocol and Mastercard's Agent Pay both build on Web Bot Auth, signed HTTP requests that carry a tag saying whether the agent is browsing (agent-browser-auth) or paying (agent-payer-auth). Cloudflare described the checks it runs for merchants in its agentic commerce post. UCP asks for the same kind of identity at the protocol level, through the agent profile.
Identity is also where the main legal fight has been. In Amazon v. Perplexity, the Ninth Circuit vacated a preliminary injunction against Perplexity's Comet agent on August 4, 2026. The court wrote that "it is the user who 'accesses' Amazon's computers, with the help of the Assistant," so Amazon was unlikely to win under the CFAA. The opinion notes that the dispute centered on Perplexity's decision not to send a user-agent string identifying the agent. A footnote adds that the outcome "does not impair Amazon's ability to regulate access to Amazon.com via private terms of service for its users." The case went back to the district court. A store's terms still apply to your agent, and is data scraping legal covers the wider picture.
FAQ
What is an AI shopping agent?
Software that searches, compares, and buys products on a person's behalf. It works through a merchant's commerce protocol, the buyer's own browser, or a browser the developer runs. Google's UCP checkout, Perplexity Comet, and agents built on Browser Use cover those three routes.
Can AI shopping agents buy things for you?
Yes, on some routes. Google's UCP checkout lets shoppers buy from eligible retailers inside AI Mode and Gemini, and Shopify's WebMCP checkout lets browser agents submit orders once the buyer approves. On other stores, a self-hosted agent has to drive the normal checkout, where the store's terms and bot checks apply.
Why does my AI shopping agent see the wrong prices?
Usually because the store placed it in the wrong country. In our test, a German server was sent to the German storefronts of Nike, Glossier, and SKIMS, and those stores then set a localization cookie that carried the market into later requests. Run the agent from the buyer's country, or pass the country explicitly where the store has an API.
Do AI shopping agents need proxies?
Only agents you host yourself. The commerce endpoints we tested didn't gate on the agent's IP, and agents running in the buyer's browser use the buyer's connection. A self-hosted agent on a cloud server runs into edge blocks and wrong-country storefronts. An IP in the buyer's country fixes the storefront. In our test the edge blocks pointed to the datacenter address, but we didn't confirm that a residential or ISP IP clears them.
Should a shopping agent rotate IPs?
Not within a buyer session. Keep one exit IP from search to checkout handoff, because location and bot-management state build up on the first requests. Rotation fits read-only price checks spread across many products or stores.
Is it legal to use an AI shopping agent on Amazon?
The Ninth Circuit held in August 2026 that Amazon was unlikely to win its CFAA claim against Perplexity's Comet, because the user, not Perplexity, accessed Amazon. The case continues, and the court said Amazon can still regulate access through its terms of service.
Final thoughts
An AI shopping agent's biggest network decision is its route. Where a store publishes a UCP profile, use it: market and buyer are parameters, carts are IDs, and in our test the call cost a fraction of a page load with no bot check. Where it doesn't, a self-hosted agent needs one exit IP per buyer session in the buyer's country, a cookie jar it never sheds, and a block check that looks past the status code. If that agent runs long, logged-in sessions, compare ISP proxy plans for static US addresses.
