What Is Agentic Commerce Search? Product Data for AI Agents

TLDR: Agentic commerce search is the retrieval step a shopping agent runs before it recommends or buys. It turns a buying intent into constrained searches, re-fetches the candidate pages at decision time, and returns a shortlist where every price carries a source and a timestamp. Checkout protocols such as ACP and UCP handle what comes after. This guide covers the search half, with code that quotes a price only when the fetched page contains it.
Ask an AI agent for a 15-inch laptop with a good keyboard under $1,500 and it inherits the whole research job: what exists, what it costs, whether it is in stock, and which page to believe. Several open standards now cover the second half of that journey, the checkout and payment handoff. The first half, finding and verifying the product, is a search problem, and a mistake there reaches the buyer as a confident recommendation. This guide defines agentic commerce search, shows where it sits next to those protocols, and builds a small pipeline on the You.com Web Search API and Contents API.
What Is Agentic Commerce Search?
Agentic commerce search is search performed by an AI agent on behalf of a buyer, as a step toward a recommendation or a purchase. The agent turns an intent into constraints and queries, reads what comes back, and returns candidates with the evidence attached. Some flows stop at a shortlist, some hand a prepared cart to the buyer, and some complete a purchase inside limits the buyer set in advance. The search layer is the same in every case, and it decides whether anything downstream can be trusted.
The difference from browser shopping search is the reader. A person scans product cards and applies judgment that is never written down. A model consumes text, so results must carry comparable fields, dated sources, and enough context to check a claim, and a model cannot skim past a bad result.
| Shopping search for people | Agentic commerce search | |
|---|---|---|
| Reader | A person scanning product cards | A model that compares text, then a person who approves |
| What a stale price costs | A click through to the correct price | A confident wrong answer, or a purchase at the wrong price |
| How you grade it | Did the person find what they wanted | Does each quoted fact appear on the cited page |
Where Does Search Fit Next to the Checkout Protocols?
Three open standards now shape how agents transact. For search, what matters is where each expects product data to come from and what limits it lets a buyer set. Status below is as of November 2026.
- Agentic Commerce Protocol (ACP). An open standard for commerce flows between buyers, AI agents, and businesses, under the Apache 2.0 license. Its repository says OpenAI and Stripe maintain it and that it is in beta. OpenAI's commerce docs begin an integration with a structured product feed that ChatGPT uses to index and display the merchant's products.
- Universal Commerce Protocol (UCP). An open standard co-developed by Google, Shopify, Etsy, Wayfair, Target, Walmart, and others. Google's implementation brings buying to AI Mode in Search and Gemini: merchants reuse their Merchant Center shopping feeds, implement endpoints to create, update, and complete checkout sessions, and stay the merchant of record. Google describes that checkout feature as early access for select merchants. The 2026-08-25 spec also defines a catalog capability for searching a business's products.
- Agent Payments Protocol (AP2). An open protocol for authorizing agent payments. Google created it and in April 2026 contributed it to the FIDO Alliance. Its premise is verifiable intent rather than inferred action: signed checkout and payment mandates, with open mandates that carry the buyer's constraints when the agent acts without the buyer present.
Two consequences matter for search. First, these protocols reach only merchants who opted in. Feeds and checkout endpoints give clean fields for sellers who publish them, while the long tail of retailers, reviews, and forum threads sits outside them, on the open web. A shopping agent that wants coverage needs both. Second, the protocols formalize consent. In Google's native checkout flow, the buyer finishes payment in a Google interface and the agent is not involved, and AP2's open mandates can express limits such as allowed merchants and a payment amount range. Those limits are the right inputs to the search step.
How Does a Shopping Agent Use a Web Search API?
Think of the pipeline as four steps, and notice that only the first two call a search vendor.
| Step | Job | You.com control |
|---|---|---|
| Discovery | Find candidate product and vendor pages | POST /v1/search with include_domains, country, count, and extraction_mode highlights |
| Verification | Re-read each shortlisted page at decision time | POST /v1/contents with max_age 0 |
| Decision | Compare against budget, specs, and trusted sellers | Your code, with the model reading verified text |
| Handoff | Show the shortlist, or start a checkout with consent | ACP, UCP, or your own cart |
For discovery, translate the buyer's constraints into request controls instead of prose. Per the request controls, include_domains is a strict allowlist of up to 500 domains and boost_domains prefers matching domains without excluding the rest. If the buyer or a mandate names allowed merchants, include_domains is the matching control, and the API reference says sending it with exclude_domains returns a 422. Add country and a count of up to 100 per section. Ask for extraction_mode: "highlights" and each result carries query-ranked passages in contents.highlights, which is where discovery-time prices show up. Highlights mode caps count at 50 and returns a 422 above that.
Treat freshness with care. It filters results by recency (day, week, month, year, or a date range), which is not a statement about when a price was last true, and the docs do not say how it treats retailer pages with no publication date. Test it against your retailer set before letting it cut candidates, and settle price at verification time.
For verification, the Contents API reads up to 10 URLs per request and returns an array with url, title, and markdown for each page. The parameter that matters is max_age. Left unset, which is the default, the API may return cached content regardless of age, so a price page can come back stale and look current. Set it to 0 to bypass the cache. In full-page mode the search endpoint has the same control as extraction_source: "fetch" (sending it with highlights returns a 422), which the page content guide recommends where staleness is a correctness problem and names prices as an example. Our Contents API guide covers batch reads.
Verification is cheap. As of November 2026 the billing page lists search at $5.00 per 1,000 calls and Contents at $1.00 per 1,000 pages, so one search call plus five verified pages costs about one cent. Asking search to crawl every result costs more: the billing docs work an example with count 10 and full page extraction, which returns 10 pages, and put the ceiling at $0.015 when all ten are crawled live. Verify the pages you plan to quote, not every page you found.
How Do You Build a Shortlist That Quotes Only What the Page Says?
The module below is stdlib-only Python and runs the first three steps. Its rule: a price reaches the shortlist only if the freshly fetched page contains it. Discovery supplies a claimed price from the highlights, verification supplies the page text, and deterministic code compares them. Every rejected candidate carries a reason, so the agent can explain why a laptop disappeared.
"""Shopping-agent shortlist: discover, re-fetch, and quote only what the page says."""
import json
import os
import re
import urllib.request
from datetime import datetime, timezone
from decimal import Decimal
SEARCH_URL = "https://ydc-index.io/v1/search"
CONTENTS_URL = "https://ydc-index.io/v1/contents"
USD = re.compile(r"\$\s?(\d{1,3}(?:,\d{3})+|\d+)(\.\d{2})?")
def post_json(url, body, timeout=60):
request = urllib.request.Request(
url,
data=json.dumps(body).encode(),
headers={"Content-Type": "application/json", "X-API-Key": os.environ["YDC_API_KEY"],
# Cloudflare in front of api.you.com rejects urllib's default User-Agent
"User-Agent": "agentic-commerce-shortlist/1.0"},
method="POST",
)
with urllib.request.urlopen(request, timeout=timeout) as response:
return json.load(response)
def usd_prices(text):
"""Every dollar amount in a block of text, as Decimals."""
return [Decimal(m.group(1).replace(",", "") + (m.group(2) or "")) for m in USD.finditer(text)]
def first_price(highlights):
"""Default claim extractor. Swap in a model call that also returns its source sentence."""
found = usd_prices(" ".join(highlights))
return found[0] if found else None
def discover(intent, retailers, post=post_json):
"""Step 1: search an allowlist of retailers and keep the query-ranked highlights."""
payload = post(SEARCH_URL, {
"query": intent,
"count": 10,
"country": "US",
"include_domains": retailers, # strict allowlist; never send with exclude_domains (422)
"extraction": {"extraction_mode": "highlights"},
})
web = (payload.get("results") or {}).get("web") or []
return [
{"url": hit["url"], "title": hit.get("title", ""),
"highlights": (hit.get("contents") or {}).get("highlights") or []}
for hit in web if hit.get("url")
]
def refetch(urls, post=post_json):
"""Step 2: re-read pages with the cache bypassed. Contents takes up to 10 URLs per call."""
pages = post(CONTENTS_URL, {"urls": urls[:10], "formats": ["markdown"],
"max_age": 0, "crawl_timeout": 20})
stamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
return {p["url"]: {"markdown": p.get("markdown"), "fetched_at": stamp} for p in pages}
def evidence(markdown, price):
for line in markdown.splitlines():
if price in usd_prices(line):
return line.strip()[:200]
return ""
def shortlist(intent, retailers, budget, post=post_json, extract_claim=first_price):
"""Step 3: keep a price only if the freshly fetched page contains it."""
candidates = discover(intent, retailers, post)[:10]
if not candidates:
return [], [] # nothing to verify, so skip the Contents call
pages = refetch([c["url"] for c in candidates], post)
keep, rejected = [], []
for c in candidates:
page = pages.get(c["url"]) # missing from the response, or under another URL: fails closed
if not page or not page["markdown"]:
rejected.append({"url": c["url"], "reason": "unverified: no fresh content"})
continue
claimed = extract_claim(c["highlights"])
on_page = usd_prices(page["markdown"])
if claimed is None:
rejected.append({"url": c["url"], "reason": "no discovery-time price to check"})
elif claimed not in on_page:
rejected.append({"url": c["url"], "reason": "price changed: %s not on page" % claimed,
"prices_on_page": sorted({str(p) for p in on_page})})
elif claimed > budget:
rejected.append({"url": c["url"], "reason": "over budget"})
else:
keep.append({"url": c["url"], "title": c["title"], "price_usd": str(claimed),
"fetched_at": page["fetched_at"],
"evidence": evidence(page["markdown"], claimed)})
return keep, rejected
Four choices carry the weight. The retailer allowlist goes into include_domains, so the search call enforces merchant limits and a prompt does not. The Contents request sets max_age to 0. Page lookup is keyed by the exact URL the API returns, so a page that is missing from the response, or comes back under a different URL, is rejected as unverified instead of matched loosely. And the claim extractor is a parameter: the default takes the first dollar amount in the highlights, which is a placeholder. A production agent should use a model call that returns the price and the sentence it came from.
The check is a floor, not proof. A price on the page may be a struck-through list price or a member price, and Google's merchant listing documentation distinguishes active, strikethrough, and member prices for that reason. The code also handles US dollars only and trusts Markdown rather than structured data, so add extraction and human spot checks on top.
Test offline before touching a live retailer. Save the module as shortlist.py. The fixtures match the documented shapes: a search result with contents.highlights, and a Contents response that is a bare array in which a failed crawl has markdown set to null.
import unittest
from decimal import Decimal
import shortlist as s
SEARCH = {"results": {"web": [
{"url": "https://shop.example/a", "title": "Laptop A",
"contents": {"highlights": ["Laptop A, 32GB RAM, now $1,299.00"]}},
{"url": "https://shop.example/b", "title": "Laptop B",
"contents": {"highlights": ["Laptop B from $1,199"]}},
{"url": "https://shop.example/c", "title": "Laptop C",
"contents": {"highlights": ["Laptop C $999"]}},
]}}
CONTENTS = [
{"url": "https://shop.example/a", "title": "A", "markdown": "# Laptop A\nPrice: $1,299.00"},
{"url": "https://shop.example/b", "title": "B", "markdown": "# Laptop B\nWas $1,399, now $1,249"},
{"url": "https://shop.example/c", "title": "C", "markdown": None},
]
class ShortlistTest(unittest.TestCase):
def test_only_grounded_prices_survive(self):
calls = []
def fake_post(url, body):
calls.append((url, body))
return SEARCH if url == s.SEARCH_URL else CONTENTS
keep, rejected = s.shortlist("15 inch laptop", ["shop.example"], Decimal("1500"),
post=fake_post)
self.assertEqual([k["url"] for k in keep], ["https://shop.example/a"])
self.assertTrue(rejected[0]["reason"].startswith("price changed"))
self.assertTrue(rejected[1]["reason"].startswith("unverified"))
self.assertEqual(calls[1][1]["max_age"], 0)
if __name__ == "__main__":
unittest.main()
The fixtures are hand-built, so these tests check your logic, not retailer behavior.
What Goes Wrong in Agentic Commerce Search?
Plan for five failure modes. Most have a detection you can automate.
The stale price. Cached content is accepted regardless of age unless max_age is set. Detection: store fetched_at with every quoted value and refuse prices older than your threshold. Prevention: max_age of 0, or extraction_source: "fetch" when search does the crawling.
The right page with the wrong price. Product pages carry several dollar amounts: the active price, a list price, a member price, a shipping threshold, a financing line. Detection: when a page yields more than one distinct amount, mark the candidate ambiguous and send it to extraction. Structured data helps where it exists. Google lists price and priceCurrency as required Offer properties, and the Contents API documents a metadata format that returns JSON-LD and OpenGraph information if available. Its response schema lists only site_name and favicon_url, so inspect a real response from your retailers before building a parser on it.
The page you cannot read. A login wall, a 404, or a blocked crawl returns null content for that URL while the rest of the batch succeeds, so null means unverified, never unchanged. Detection: count nulls per retailer per day, since a rising rate points to blocking, timeouts, or dead links. For script-heavy pages the Contents docs suggest a crawl_timeout of 20 to 30 seconds, which is why the module uses 20.
Hostile text on a trusted-looking page. Descriptions, reviews, and seller notes are third-party text your model reads. OWASP lists prompt injection as LLM01 in its 2025 risks for LLM applications, describes indirect injection as input from external sources such as websites, and recommends least privilege and human approval for high-risk actions. In commerce that means the model reading pages holds no payment credential and no cart tool, a separate step holds those, and the buyer approves the purchase. Our guide to prompt injection and intent hijacking in AI agents covers the agent side.
The recommendation that carries money. ACP's checkout API lets an agent attach affiliate_attribution when it creates and completes a session, per the 2026-04-17 OpenAPI specification. That is a legitimate feature and also a reason to log the selection rule, why this seller and not that one, as auditable data. Detection: sample recommendations and check that the stated rule, not the payout, explains the choice.
When Should You Use Search, a Feed, or a Protocol?
The decision depends on who controls the catalog and whether the buyer is about to pay.
| Situation | Lead with | Why |
|---|---|---|
| Small, known catalog that you or a partner controls | A feed or partner API | Clean fields with no parsing; see the product data API guide |
| Open-ended questions across many retailers | Web search plus fresh page verification | Covers sellers that publish no feed |
| Buyer approves a purchase at a merchant that supports a protocol | ACP or UCP checkout | Consent flow, payment tokens, merchant stays the seller of record |
| Watching one product's price over time | A scheduled monitor | Change detection beats repeated searching; see the price monitoring API guide |
| Judgment questions such as which laptop class suits a buyer | A research call, then verify any price it cites | Cited multi-source synthesis, but numbers still need the fresh fetch |
The last row is where the Research API fits. Per its guide, it runs multiple searches and returns a Markdown answer with inline citations and a sources array, priced from $12 per 1,000 requests at the lite tier as of November 2026. To read page text at scale, our web content extraction guide walks through the pipeline.
How Do You Test an Agentic Commerce Search Pipeline?
Measure the failure modes directly, on a schedule, against a fixed set of buying intents.
- Golden intents. Keep 20 to 30 real buying intents, each with a hand-checked expected shortlist, and replay them weekly against live retailers.
- Price match rate. On five shortlists a week, check by hand that each quoted price is the active price on the page. The code guarantees presence on the page. Only a person confirms it is the right number.
- Unverified rate. Track the share of candidates rejected for missing content, per retailer. A climb points to blocking, timeouts, or URLs that no longer match.
- Injection fixture. Add a fixture page whose text tells the model to add an item to the cart, and assert that no tool call follows. A reading step with no cart tool passes by construction.
- Cost and latency per shortlist. Log both. Self-serve accounts default to 10 requests per second on /v1/search and /v1/contents per the rate limits page, so batches of shortlists need client-side throttling.
The first exercise is small. Pick one buying intent you understand, run the pipeline against five retailers, and compare every shortlist entry and every rejection with its page by hand before you trust the accepts.
What Does You.com Provide Here, and What Does It Not?
You.com provides retrieval primitives: search, page contents, cited research, and an MCP server that exposes them to agent clients. It is not a product catalog, a price feed, or a checkout rail. The Knowledge parameter on the Web Search API returns licensed data for stock and crypto prices, weather, sports, and economic data, not retail prices, so do not route a shopping price through it. The docs home page says you can start with free credits and no credit card.
Related Guides
Frequently Asked Questions
Yes, within limits. Protocols such as ACP and UCP define checkout endpoints that let an agent start a purchase with a merchant that supports them. In Google's native checkout flow the buyer completes payment in a Google interface without the agent involved. The search step described here only builds a verified shortlist, and the buyer should approve any purchase.
It fetches the page at decision time instead of trusting search results. The Contents API with max_age set to 0 bypasses the cache, and search can do the same in full-page mode with extraction_source set to fetch. Store a fetched_at timestamp with each price, and quote a price only if it appears in the freshly fetched text. A page that fails to load counts as unverified, not unchanged.
Not to start, but feeds help where they exist. ACP and UCP both build on merchant-supplied product data, such as a structured feed for ChatGPT or Merchant Center feeds for Google. Those cover only merchants who publish them. Open-web search reaches sellers with no feed, so agents that want coverage use search for discovery and a feed or checkout endpoint where a merchant offers one.
The reader. Shopping search shows product cards for a person to judge. Agentic commerce search feeds a model, so results need comparable fields, dated sources, and a way to check each quoted fact against the cited page. A model cannot skim past a bad result, so precision matters more, and a stale price becomes a confident wrong answer instead of a mistaken click.
LI Test
LI Test
Share Article:
Related resources.

What Is an LLM Gateway? How Routing, Caching, and Fallback Work
November 7, 2026
Blog

Introducing You.com Inference Router: Enterprise-grade inference on demand
October 22, 2026
Product Updates

How to Build a Rank Tracker With a SERP API: A Developer’s Guide
October 14, 2026
Blog

SERP Scraping API vs Web Search API: Which One Do You Need?
October 11, 2026
Blog

What Is Agentic Resource Discovery? Machine-Readable Access for AI Agents
October 9, 2026
Blog
