Ecommerce Automation

Agentic Checkout: ACP, AP2, and Who Eats the Chargeback

Rushil ShahRushil Shah
13 min read
Share

Every explainer tells you what the agentic commerce protocols are. None trace the six operational seams a merchant inherits — feed, mandate, credential, auth signal, reconciliation, dispute — or say which ones to leave manual.

TL;DR

Agentic checkout is six integrations, not one, and they fail independently. The catalog feed, order-channel tagging and reconciliation layers are safe to build this quarter and cheap insurance either way. The dispute layer is not: no card network has published a merchant-facing reason-code mapping for agent-initiated purchases, which means today the merchant absorbs the loss by default. Build the plumbing that lets you isolate and measure agent orders before you build the checkout surface that creates them.

The Six Layers You Actually Inherit

When an ecommerce leader asks whether to “support agentic checkout”, the real question is which of six independent layers they are committing to operate. Each has a different owner inside the business, a different failure mode, and a different maturity level in the published specs. Treating them as one project is how teams end up with a working checkout endpoint and an unmeasurable chargeback line.

The layer map of an agent-initiated order

1
Catalog feed

Structured product, variant, price and inventory data leaves your system and is cached by an agent surface you do not control.

↓
2
Intent and mandate capture

The buyer approves a purchase inside the agent UI. You never render that screen, and you do not hold the artifact that proves consent.

↓
3
Payment credential

A scoped, single-transaction credential or network token arrives at your checkout instead of a PAN typed into your form.

↓
4
Authorization signal

Your gateway sends the auth. Whether it is flagged as delegated or agent-initiated at the acquirer depends on fields most merchants have never looked at.

↓
5
Reconciliation

The order lands in the OMS with no cookie, no UTM, no device fingerprint and no prior cart history to join on.

↓
6
Dispute and returns

60 to 120 days later a chargeback arrives, and your representment evidence depends on records held by a third party.

Layers 1 and 5 are ordinary data engineering. Layers 2, 4 and 6 are where the published specs are thinnest and where the commercial exposure concentrates.

What ACP Asks You to Build

The Agentic Commerce Protocol is the most concrete option on the table because it ships with two reference implementations rather than a whitepaper. The spec is maintained by OpenAI and Stripe, carries an Apache-2.0 licence, and is still formally marked beta, with dated snapshot releases running from 2025-09-29 through the current stable 2026-04-17, which added cart, feed, orders, authentication and MCP surfaces.

5 dated ACP spec releases between Sept 2025 and Apr 2026, plus an active unreleased branch Source: ACP repository, 2026
86 open issues on the ACP spec repo alongside 51 open pull requests, while status remains beta Source: ACP repository, 2026
7 user signals OpenAI relays to merchants via the Forwarded header — the entire fingerprint you get Source: OpenAI Commerce docs, 2026

Two details in the OpenAI merchant guidance do more to shape your build than the protocol diagrams. First, the risk problem is explicit: the cloud browser driving the purchase can trip bot-detection systems tuned on IP and browser signals and cause purchases to fail, which is why user context is relayed through the Forwarded HTTP header — asn, for, ip-country, ip-prefix, locale, tz and user-agent. That is your replacement for a device fingerprint. It is seven coarse fields, some of which may be absent depending on rollout. Your fraud vendor has to be told to ingest them.

Second, the credential is narrow and the responsibilities are not shared. The merchant receives a network token rather than a full card number and uses the Payment Account Reference (PAR) to associate that token with the underlying account, and consent covers only the specific transaction — the credential must not be reused or saved for a separate purchase. Recurring billing is possible only if your checkout already supports it, with consent captured and merchant-initiated transaction best practice followed.

Your business handles the order, fulfillment, customer support, and fraud decisions.

— OpenAI Commerce documentation, Accept payments

That single sentence is the liability model. It is not hidden, it is not hedged, and it has not changed as the spec has matured.

ACP, AP2, and the Network Credential Schemes

The honest framing is that these are not competitors occupying the same slot. ACP standardises the merchant-facing checkout conversation. Google’s AP2 is aimed at the authorisation-evidence problem — cryptographically signed mandates that record what the user actually agreed to before an agent spends. The card networks’ schemes (Visa’s Trusted Agent Protocol, Mastercard’s Agent Pay) sit underneath both, at the credential and agent-identity layer, and are the only ones that can ultimately move liability, because liability lives in network operating rules rather than in open-source repositories.

Expect the surface to keep splitting rather than converging. Stripe’s own agentic commerce documentation now lists Shared Payment Tokens, a catalog feed, and a separate Universal Commerce Protocol (UCP) alongside agent-side products such as Link Agent Wallet, WebMCP browser flows, and machine payments via MPP and x402. If your integration hard-codes one protocol’s object model into your order schema, you will rewrite it.

StackWhat it standardisesArtifact you end up holdingMerchant verdict today
ACP (OpenAI / Stripe)Feed, cart, checkout and delegated payment between agent and merchantNetwork token plus PAR, order and session referencesBuild it — working reference implementations, but pin the spec version
AP2 (Google)Signed mandates evidencing user intent and cart approvalA verifiable credential you may only see by referenceWatch and prototype — strongest answer to the evidence problem, thinnest merchant tooling
Network schemes (Visa TAP, Mastercard Agent Pay)Agent identity and delegated card credentials inside the railsWhatever your acquirer chooses to expose in the auth and settlement recordsAsk your acquirer, do not build — this is the layer that decides liability
Browser agent on your existing checkoutNothing — it is a normal CNP transaction driven by softwareHeaders, if the agent vendor sends anyAlready happening to you whether or not you integrated anything

That last row is the one most teams miss. The decision is not whether to let agents buy from you. It is whether agent purchases arrive labelled or unlabelled.

Who Eats the Chargeback

You do, for now, in the ordinary case. I have not found a published, merchant-readable mapping from the card networks that assigns agent-initiated purchases a distinct dispute reason code with a defined liability shift, and until that exists in the operating rules, an agent-driven order disputed by a cardholder is processed under the same card-absent framework as any other ecommerce transaction. Anyone telling you the liability question is settled is selling an integration.

The sharper problem is evidentiary. Three distinct scenarios collapse into one chargeback form:

The agent bought the wrong SKU. The buyer approved “running shoes, size 10”; the agent resolved it against your feed to the wrong colourway or the wrong width. That is a merchandise-not-as-described condition, not fraud — but the customer experiences it as “I did not order this” and will often file it as unauthorised. Your defence is the item snapshot at time of order and the feed version the agent resolved against. If you do not store the feed version hash with the order line, you cannot reconstruct what the agent saw.

The agent bought at a stale price. Agent surfaces cache your feed. A promotion ends, the cached price persists, the order arrives at the old total. Decide now whether you honour it. Whichever way you decide, the decision must be a rule in your order pipeline, not a judgement call made by a support agent under pressure.

The credential was genuinely compromised. Here you have fewer signals than a normal CNP order, not more: no device fingerprint, no returning-customer cookie, no browsing history leading to the cart. The PAR is your most useful join key — it lets you link multiple tokens back to one funding account for velocity checks, repeat-return abuse and refund matching, which is exactly what you lose when the session is non-human.

!

Agent identity headers, request signatures, idempotency keys and mandate or session references arrive as HTTP metadata, so they land in whatever log sink the API gateway uses — typically with 14 to 30 day retention. Disputes arrive 60 to 120 days later. By the time you need the evidence, it has rolled off, and the only remaining copy is held by the agent platform whose contract may not oblige them to produce it for you.

Fix: persist the full agent context onto the order record itself, not the log stream, with retention that exceeds your longest dispute window. Then put the retrieval obligation and an SLA into the agent platform contract before you go live.

Where Your OMS, Fraud Stack and Returns Break

The integration is small. The operational blast radius is not.

Amount adjustment at capture. Many merchants authorise at order and capture at ship, often with a different amount: split shipments, substitutions, weight-based shipping, backorders. A credential that is explicitly scoped to one approved transaction does not accommodate that pattern. Every delta becomes an exception. Before launch, map which of your fulfilment paths can produce a capture amount that differs from the authorised total, and exclude those categories from agent checkout until you have tested them end to end with your PSP.

Fraud scoring on a null fingerprint. Your risk model probably leans on device ID, behavioural signals and session depth. All three are absent. Agent orders sent through the same model will either be declined wholesale or sail through on a default score, and both outcomes are invisible unless the channel is tagged.

!

Blocking the agent, or blanket-allowing its ASN

The first instinct of a WAF team meeting datacentre traffic at checkout is to block it. The second, after losing orders, is to allowlist the whole autonomous system. Both are wrong: the first destroys the channel, the second removes bot protection for anyone who can rent capacity in the same network range.

Fix: route instead of blocking. Verify the agent’s request signature, score on the relayed user context (ip-country, asn, ip-prefix) plus PAR-level velocity, and send borderline agent orders to a manual review queue rather than a hard decline while you build a baseline.

Returns and support. A returns workflow that emails a portal link to the account holder breaks when the purchase was made in a conversation, possibly without an account on your store. Decide up front whether an agent order creates a customer record, how the RMA is initiated, and who the refund goes back to when the credential was single-use.

Attribution. No referrer, no UTM, no cookie. If agent orders are not tagged with a dedicated channel code at creation, you cannot compute their chargeback rate, return rate or margin — and “we think it is fine” is not an answer your CFO will accept six months in.

A Build Sequence That Doesn't Strand You

Order matters more than tooling here. This sequence works whether you assemble it in n8n, Temporal or application code, and each step is useful even if you abandon the next one.

1. Channel tagging first, before any agent integration. Add an order-source field and a JSON column for agent context to your order schema today. Backfill nothing; just start capturing. This is a half-day of work that makes every later decision measurable.

2. Feed pipeline as a one-way idempotent job. A scheduled workflow pulls products, variants, price and inventory from your commerce platform, normalises them to the feed schema, validates parity against your live PDP prices, and publishes with a version hash stored alongside. Fail the run on variant-completeness or price-drift thresholds rather than publishing a bad feed. Never let the agent surface write back into inventory.

3. Checkout exposure behind a flag, on a narrow SKU set. Start with low-ticket, non-perishable, non-regulated, single-shipment items with a clean variant structure. Exclude anything with a restocking cost or an amount that can change at capture.

4. Evidence capture at order creation. Persist agent identity, signature verification result, idempotency key, mandate or session reference, the full item snapshot and the feed version hash onto the order. This is the single highest-value automation in the whole stack — it is also the one no vendor builds for you. We treat this pattern as the default for any order-ingestion workflow that spans a third-party surface.

5. Nightly reconciliation keyed on PAR plus idempotency key. Match acquirer settlement records to agent-channel orders and alert on anything unmatched in either direction. Duplicate agent submissions are a real failure mode when a retry crosses a timeout.

6. Dispute assembly assisted, not automated. When a chargeback webhook arrives on an agent-channel order, auto-assemble the evidence pack — and then have a human send it. Auto-representment rules tuned on web traffic will mis-fire on a transaction type whose reason-code conventions are not yet stable.

Layers that should stay manual until network rules settle: high-ticket orders, anything with post-authorisation amount changes, subscription creation from an agent session, and auto-approval of agent-initiated returns. If you want the sequencing argued against your own stack rather than in the abstract, that is the kind of thing we scope in an integration assessment.

A Test Harness for Agent-Initiated Orders

You do not need an agent platform to find most of these breakages. You need to replay an agent-shaped request against your own checkout from an address that looks nothing like a consumer. The crude version below surfaces WAF blocks, fraud declines and missing-channel-tag bugs in an afternoon.

bash
# Replay an agent-shaped checkout against staging.
# Run it from a cloud VM, not your laptop: the datacentre ASN is the point.

for i in $(seq 1 25); do
  curl -sS -X POST https://staging.example.com/checkout \
    -H 'Content-Type: application/json' \
    -H 'Idempotency-Key: harness-'"$i" \
    -H 'Forwarded: asn=64496;ip-country=GB;ip-prefix="192.0.2.0/24";tz="Europe/London"' \
    -H 'User-Agent: HarnessAgent/1.0' \
    -d '{"items":[{"sku":"TEST-SKU-10","qty":1}],"channel":"agent-test"}' \
    -o "out-$i.json" -w '%{http_code} %{time_total}\n'
done

# Assertions to run against the results, not just eyeball:
#  1. every order carries channel=agent in the OMS record
#  2. 25 identical idempotency keys produce 25 orders; 25 repeats produce 0 extra
#  3. no request is silently dropped by the WAF (watch for 403/429 bursts)
#  4. fraud score distribution differs from the web baseline - and is logged
#  5. item snapshot and feed version hash are persisted on every order line

Run the same loop with a deliberately stale price, a discontinued variant and a quantity that exceeds stock. The interesting results are not the failures; they are the cases that quietly succeed and create an order you cannot fulfil. Those are the orders that become disputes. If you want a worked example of the harness wired into a scheduled pipeline with assertions as workflow nodes, tell us what your stack looks like.

Frequently Asked Questions

What does agentic commerce protocol integration actually involve for a merchant?

Six separable pieces: publishing a structured catalog feed, exposing cart and checkout endpoints an agent can call, accepting a scoped payment credential instead of a card form, ensuring the authorisation is coded correctly at your acquirer, tagging and reconciling the resulting orders, and handling disputes and returns for a buyer who never visited your site. The first and fifth are low-risk and worth doing immediately.

ACP vs AP2 — which should I implement first?

They solve different problems, so the question is usually mis-posed. ACP standardises the merchant-facing checkout exchange and ships with reference implementations from OpenAI and Stripe, so it is the practical first build. AP2 targets signed mandates proving what the buyer authorised, which matters most at dispute time. If you only have budget for one integration this quarter, build ACP and design your order schema so a mandate reference can be attached later.

Who is liable when an AI agent buys the wrong product?

In practice the merchant. OpenAI’s merchant documentation states plainly that the business handles order, fulfilment, customer support and fraud decisions. No card network has published a merchant-facing liability shift specific to agent-initiated purchases, so a disputed agent order is handled under existing card-absent rules. Your protection is evidentiary: store the item snapshot, feed version and consent references with the order.

Is there a specific chargeback reason code for agentic transactions?

Not one that merchants can design workflows against today. Agent-initiated disputes arrive under the familiar categories — unauthorised transaction, goods not received, not as described — which means a wrong-SKU purchase and a genuine fraud case can land on your desk looking identical. Ask your acquirer directly what field, if any, identifies delegated or agent-initiated authorisations in your settlement files, and get the answer in writing.

How do I stop my fraud and bot systems from killing agent checkout?

Do not allowlist the agent’s network range. Verify the agent’s request signature, then score on the relayed user context — OpenAI forwards parameters such as origin ASN, observed IP, country, masked prefix, locale, timezone and user agent through the Forwarded header. Configure your risk provider to ingest those fields, run agent traffic through a separate rule set, and send borderline cases to manual review rather than a hard decline.

Can I save the agent’s payment credential for later charges or a subscription?

No. OpenAI’s guidance is explicit that the customer consents only to the specific transaction and the credential must not be reused or saved for a separate purchase. Recurring billing is possible only where your checkout already supports it, with consent collected and your processor’s merchant-initiated transaction practices followed. Audit any flow that adjusts the captured amount after authorisation before exposing it to agents.

Should I expose my entire catalog to buying agents?

Start narrow. Low-ticket, single-shipment, non-perishable, non-regulated items with a clean variant structure give you real data with contained downside. Hold back high-ticket goods, anything with a restocking cost, products whose capture amount can differ from authorisation, and categories where an ambiguous variant match is likely. Widen the set once you have seen a meaningful number of agent orders through a full dispute and returns cycle.

agentic commerceACPAP2paymentsecommercechargebacksworkflow automationintegration

Published

AI-assisted writing · Reviewed by the Twarx research team

Share:
Share

Research digest

AI Research Briefing

Honest insights on AI agents, Small Language Models, and local RAG. No hype. Only when we have something worth sending.

  • No hype, just measurable outcomes
  • Read by 2,400+ engineers
  • Unsubscribe anytime

Continue reading

More from Articles

Ecommerce Automation

How to Automate Ecommerce Operations With AI Agents in 2026: Close the Agent Execution Gap

16 min read
Ecommerce Automation

AI Agents for Ecommerce Automation in 2026: The 3-Layer Stack Framework

16 min read
Ecommerce Automation

Order Management Agents: Where the Money Leaks

16 min read
Ecommerce Automation

Where Ecommerce Agents Break: Inventory Meets Order Status

16 min read
Ecommerce Automation

Order Ops Agents Fail Between Shopify, WMS and Stripe

16 min read