We Let Perplexity Buy From Our Store. Here Is What Broke.

In April we ran a controlled experiment with one of our DTC merchant partners — a mid-market apparel brand on Shopify — and Perplexity's shopping agent. The objective: let real Perplexity sessions complete real purchases against the live catalogue, observe what broke, fix as we went, and document the failure modes other operators will hit when they run the same playbook.

The experiment ran for 14 days. 1,142 sessions reached cart, 318 completed checkout, 96 returned a fault that needed engineering attention. This is the post-mortem.

Setup

We exposed three things to Perplexity's agent: the Shopify Storefront API, a clean product feed in JSON-LD, and a verified-buyer review corpus via the Idukki review API. Payment was via Stripe with a delegated-spend agreement. Agent identity was passed through the Stripe Agent Pay header, so we could distinguish agent orders from human orders in the order management system.

We also instrumented every step of the funnel: catalogue query, product fetch, add-to-cart, checkout-init, payment-confirm. Each step logged latency, payload size, and error class.

What broke

Break 1 — Inventory desync at the cart line

The most common failure (37 of the 96 faults). Perplexity's agent would query the catalogue, find an in-stock SKU, add to cart, and then fail at checkout because the SKU had sold out in the intervening 90 seconds. Standard ecommerce handles this with a polite error message; an agent treats it as an outright failure and abandons the session without retrying.

Fix: surface real-time stock at the catalogue-query layer with a "last_seen" timestamp and a confidence score. Agents now know to re-check before completing.

Break 2 — Variant collapse

24 faults. The agent reads "navy linen jacket" as a single SKU when in fact there are four size variants. It picks the parent SKU, attempts to check out, fails because the cart needs a variant ID. Our product feed structure assumed a human would pick the size on the PDP; the agent does not visit the PDP.

Fix: emit variants as first-class products in the JSON-LD with sizeRange, isAccessoryOrSparePartFor, and a parent reference. Three days of feed-template work.

Break 3 — Currency and tax surprises

19 faults. The agent saw the GBP price, calculated total, and then choked when checkout returned a different total after VAT and shipping were added. The agent expects the displayed price to be the final price.

Fix: include a priceTotalEstimate field in the product feed that reflects VAT-inclusive, shipping-included pricing for the agent's claimed shipping country. Sounds obvious; almost no brand does this.

Break 4 — Out-of-policy returns assumptions

8 faults. The agent confidently told the buyer "free returns within 30 days" while our policy is 14 days for sale items. Agent had hallucinated based on category-norm rather than reading our policy page.

Fix: bind returnPolicy explicitly to each Product in JSON-LD with a specific URL pointing to the page. Agents respect explicit policy schema; they hallucinate in its absence.

Break 5 — Two-factor auth at checkout

8 faults. Stripe's SCA challenge triggered for European cards, asked the buyer to confirm via banking app, and the agent timed out waiting. Hard problem — regulatory.

Fix: pre-authorise via Stripe Agent Pay's delegated SCA flow before the agent starts shopping. Adds one user-side step at session start but eliminates mid-checkout abandonment.

Unexpected wins

Three things we did not expect.

• Average order value via Perplexity was 22% higher than via direct web sessions. Agents bundle accessories aggressively when the underlying product page has a clean RelatedProduct schema.
• Return rate on agent orders was 4.1% versus 7.8% on direct orders, despite no human ever seeing the PDP. The agent's pre-purchase Q&A loop catches mismatches that humans miss.
• Customer service tickets dropped — when the agent has clean returns policy and sizing schema, post-purchase questions resolve at the agent layer.

What this means for operators

A small number of structural feed and policy changes turn an agent from "browses but never buys" to "completes checkouts at higher AOV and lower return rate than humans". The work is not glamorous — feed plumbing, schema fields, policy bindings — but it is concentrated and one-time.

Three things to do this quarter even if you have no Perplexity integration yet:

1. Audit your product feed for variants emitted as first-class items, not as nested options.
2. Add returnPolicy to every Product JSON-LD with a specific URL.
3. Include a priceTotalEstimate in your feed reflecting taxes and standard shipping.

Looking ahead

Perplexity is one agent. ChatGPT Commerce, Claude Shopping, Gemini Shop and Amazon's Rufus checkout will all need the same plumbing within twelve months. The brands that ship now buy themselves an 18-month visibility moat before the rest of the catalogue catches up.

Closing

The takeaway is reassuring. Agentic checkout is not a complete re-platforming. It is a focused refactor of feeds, schema and policy bindings. Two engineering weeks of work, one PM week of attribute design, and you are ready for the next twelve months of agent-driven traffic.