Introducing the Rye Product Data API
Arjun Bhargava
Co-founder and CEO @ Rye
Feb 22, 2026
9 minutes read
Real-time product data API for any merchant URL. 91% reliability across the top 450 U.S. stores. No stale data. Built for AI agents.
TL;DR / Key Takeaways
We built a real-time product data API that returns normalized product information — name, price, availability, images, and more — from any merchant URL.
The endpoint uses the same tiered retrieval architecture as our checkout infrastructure: structured APIs when available, intelligent browser-based extraction when they're not.
Product data is fetched in near-real-time with only a short-lived cache window — no long-lived caches or stale snapshots. When the API reports a product is in stock, it closely reflects the live state of the merchant site.
The API contract is a single GET request: pass a product URL, get back structured product data. It feeds directly into the checkout intent flow.
Available now. Read the docs →
Since August of last year, we've been steadily hill-climbing toward one goal: true agentic checkout.
Not a demo. Not a brittle automation layer. Real infrastructure that lets software reliably purchase anything, from any merchant, across the internet.
Along that path, we discovered something we hadn't anticipated.
Checkout isn't the only hard problem.
Product data is just as broken.
Today, we're introducing the Rye Product Data API — a real-time, agentic product data API built for the internet as it actually exists.
The Assumption We Got Wrong
When we first built the Universal Checkout API, we designed for a world where product data was already solved. There were aggregators, feeds, brokers, and structured exports. It seemed reasonable to assume product data access was a commodity layer.
It wasn't.
As we dogfooded our own API — including building demo.rye.com and worked with customers building AI-native commerce systems, we kept hitting the same issues. Inventory states were stale. Variant information was incomplete. Prices drifted. Products marked "in stock" were no longer purchasable. Schemas differed wildly across merchants.
For traditional e-commerce, these issues are frustrating.
For AI agents, they're fatal.
If an agent recommends a product that can't be purchased — or attempts a checkout that fails due to inventory drift — trust evaporates instantly. And without trust, agentic commerce doesn't work.
So we did what we've done before.
We rebuilt the layer ourselves.
Built for the Real Internet
If you want universal reach in commerce, you have to build for reality — not the ideal state of standards adoption.
Based on our analysis of the top 1,000 U.S. retailers, roughly 45% run on custom e-commerce stacks. Standards like ACP and UCP are promising, but meaningful adoption across enterprise and custom platforms will take years. Merchant APIs, when they exist, are often partial, inconsistent, or undocumented.
If you rely on APIs alone, you only reach part of the internet.
From the beginning, Rye's checkout infrastructure embraced this constraint. We use structured APIs when they're available, and intelligently fall back to agentic browser automation when they're not.
The Product Data API follows the exact same philosophy.
What We Built
A Tiered, Agentic Retrieval Architecture
At its core, the Product Data API is an adaptive retrieval system.
When merchants expose structured product APIs or data feeds, we integrate directly. This provides low-latency access and high structural fidelity when the underlying systems are reliable.
When structured endpoints are absent or incomplete — particularly across custom platforms — we fall back to intelligent browser-based retrieval. This isn't naive scraping. It leverages the same infrastructure that powers our agentic checkout system. We dynamically interpret rendered DOM structures, resolve JavaScript-driven content, and apply extraction strategies that tolerate layout and markup variation across merchants.
The extraction strategy is cached per domain — so once the system determines the optimal retrieval path for a given merchant, subsequent requests are faster. But the product data itself is fetched fresh on every call.
This is how you achieve real coverage across the internet, not just across API-friendly merchants.
Freshness as a First-Class Constraint
Most product data providers cache. From a cost and performance standpoint, that's understandable.
But caching introduces a structural weakness: the system no longer returns ground truth. It returns a historical snapshot.
We made a different decision.
The Rye Product Data API does not rely on long-lived caches. Product data is fetched in near-real-time — with only a short-lived cache window measured in minutes — so when our API reports that a product is in stock, it closely reflects the live state of the merchant site. Inventory, pricing, and availability are resolved at retrieval time, not served from stale snapshots.
This isn't a theoretical concern. Even large-scale marketplace sellers routinely encounter problems where product data brokers return cached inventory states, leading to ads for products that are already out of stock.
For AI-native commerce systems, this matters deeply. Agents require deterministic state. Checkout flows fail when availability drifts. Recommending unavailable products erodes user trust immediately.
Freshness isn't an optimization. It's infrastructure.
Reliability, Engineered From Checkout
Agentic checkout is unforgiving. Even low single-digit failure rates make systems unusable at scale.
We applied those same reliability constraints to product data retrieval. The endpoint incorporates layered validation logic, structured schema normalization, and continuous regression testing against live merchant environments. Because it's built on top of our checkout infrastructure, it benefits from hardened rendering strategies, adaptive fallback logic, and production-learned resilience patterns.
We don't treat product data as static content extraction.
We treat it as transactional infrastructure.
Built for the Checkout Pipeline
What We're Seeing
We benchmarked the Rye Product Data API against a leading market alternative across the top 450 U.S. e-commerce stores.
The result: 91% reliability versus 55.5% — meaning Rye successfully returned complete, structured product data for nearly twice as many stores. The gap was driven by our agentic browser fallback on custom platforms where traditional API-based providers fail silently, and by real-time retrieval that avoids serving stale or incomplete data.
Coverage and depth of data continue to improve week over week as cached extraction strategies expand to new merchant domains.
"Working with Rye has been an incredible experience overall. When evaluating partners, ease of use — especially around accessing product data — was critical for us. Rye's system provides clear, well-structured access to imagery, inventory signals, and product descriptions, making integration and ongoing maintenance efficient." — Shannon McKane, Caroo
Frequently Asked Questions
What product data fields does the API return?
The API returns a normalized schema across all merchants: a stable product id (in domain:identifier format), URL, SKU, name, brand, description, images (with an isFeatured flag), price (amountSubunits with ISO 4217 currencyCode), availability status (an enum with five states: in_stock, out_of_stock, preorder, backorder, unknown), and an isPurchasable boolean indicating whether the product can be purchased. The schema is designed for extensibility — fields like ratings, original price, and variant options are candidates for future releases.
Does the API cache product data?
Product data is fetched in near-real-time with only a short-lived cache window measured in minutes. The extraction strategy (which retrieval method works best for a given merchant's domain) is cached for performance, but the actual product information — price, availability, description — closely reflects the live state of the merchant site at the time of the request. There are no long-lived caches or stale snapshots.
How does this relate to the Universal Checkout API?
The Product Data API is the first step in the checkout pipeline. It gives your agent the information it needs — pricing, availability, product details — before creating a checkout intent. Your agent verifies the product is in stock and within budget, then passes the product URL into POST /api/v1/checkout-intents to complete the purchase. One call to understand the product, one call to buy it. See the checkout quickstart for the full flow.
What merchants are supported?
The API works across the same merchant surface as the Universal Checkout API. When a merchant exposes structured product data through APIs or feeds, we use those directly for speed and reliability. For merchants on custom platforms without structured endpoints, the system falls back to browser-based extraction. Coverage expands continuously as cached extraction strategies are built for new merchant domains.
What are the rate limits?
Default rate limits are 10 requests per second and 3,000 requests per month. Need higher throughput? Talk to our team → — we can configure custom limits for your use case.
Start Building
AI agents are going to shop the internet. That future is inevitable.
But agents can't operate on cached inventory, partial feeds, or optimistic availability assumptions. If we want agentic commerce to work across the full surface of the web — including the nearly half of top retailers running custom stacks — we need infrastructure built for how commerce actually works today.
The Rye Product Data API is available now. Get your API key and start building in minutes. Use the REST API directly or get started with the JavaScript SDK (checkout-intents package).
You can explore it live at demo.rye.com.
And if you're building AI shopping agents, embedded commerce experiences, or next-generation checkout systems, we'd love to work with you!
Product
Resources