Blog

Agentic Commerce Protocol and ChatGPT Checkout, Explained (2026)

How OpenAI and Stripe's Agentic Commerce Protocol works, what happened to ChatGPT Instant Checkout, how UCP and card programs compare, and what merchants must build.

Swell Team |

The Agentic Commerce Protocol (ACP) is an open specification, maintained by OpenAI and Stripe, that defines how an AI agent and a merchant's backend exchange product data, run a checkout, and pass a scoped payment credential. It standardizes four things: a product feed, a set of checkout session endpoints the merchant hosts, order webhooks the merchant sends back, and a delegated payment flow in which the agent hands the merchant's payment provider a single-use token instead of a card number. The merchant stays the merchant of record throughout.

ChatGPT Instant Checkout was the first consumer product built on ACP. It launched on September 29, 2025 for U.S. users buying from U.S. Etsy sellers. On March 24, 2026, OpenAI said the initial version of Instant Checkout "did not offer the level of flexibility" it wanted, and that it would let merchants use their own checkout experiences while it focused on product discovery. ACP did not go away. OpenAI extended it to carry product feeds and promotions for discovery, and Stripe, Google, Visa and Mastercard have all shipped or expanded adjacent programs since.

This explainer covers how the protocol works, a dated status ledger for every major spec as of October 5, 2026, what a merchant actually has to build, and what changes when your commerce backend is already API-first. For a vendor-by-vendor landscape of agentic commerce tools, see best agentic commerce platforms.

Key Takeaways

  • ACP is an Apache 2.0 licensed spec maintained by OpenAI and Stripe. It is still labelled beta, and its latest stable version is dated 2026-04-17.
  • A merchant implementing ACP checkout exposes five endpoints (create, update, retrieve, complete, cancel a checkout session), emits signed order webhooks, and accepts a delegated payment token through a payment provider that supports it.
  • In-chat Instant Checkout in ChatGPT was scaled back in March 2026. Shopify merchants selling through ChatGPT now complete purchases on their own online store checkout inside an in-app browser.
  • Google's Universal Commerce Protocol (UCP) powers a Buy button in AI Mode and Gemini for select merchants who apply through an interest form. Payment runs through Google Pay.
  • Visa and Mastercard operate the network layer underneath: agent verification, agentic tokens and risk signals. Visa reported live agent purchases in Europe in July 2026, and Mastercard enabled U.S. cardholders for Agent Pay in late 2025.
  • Fees are fragmented. OpenAI has said merchants pay "a small fee" on completed purchases without publishing a rate (Shopify merchants were reported to pay 4%), Shopify says selling in ChatGPT carries no fee beyond processing, and Stripe lists Shared Payment Tokens at $0.15 per token issued.
  • If your cart, tax, shipping and order creation are already server-side API calls, an ACP endpoint is a translation layer over them. On a hosted platform you wait for the vendor's integration.

What ACP Standardizes

OpenAI announced ACP alongside Instant Checkout in its September 29, 2025 launch post, describing it as an open standard co-developed with Stripe. The spec lives in a public GitHub repository under the Apache 2.0 license, with OpenAI and Stripe as founding maintainers and a contributor license agreement required for changes.

The repository uses date-based versions. Five have been released: 2025-09-29 (initial), 2025-12-12 (fulfillment changes), 2026-01-16 (capability negotiation), 2026-01-30 (extensions, discounts and payment handlers) and 2026-04-17 (cart, feed, orders, authentication and MCP). Each release deprecates the previous one, so an integration needs to track the `API-Version` header it speaks.

The protocol has four parts.

The product feed

The feed tells the agent what you sell. OpenAI's product feed spec accepts JSONL in OpenAI's own format or a Google-compatible delimited file (TSV or CSV, optionally gzipped). The required fields in the OpenAI format are `item_id`, `title`, `description`, `url`, `brand`, `seller_name`, `image_url`, `availability` and `price`. Titles are capped at 150 characters and descriptions at 5,000.

Variants are flattened: one row per purchasable item, each with its own `item_id` and a shared `group_id` for the parent listing. Three boolean flags control where a product can appear: `is_eligible_search` (defaults to true), `is_eligible_checkout` (requires separate enablement) and `is_ads_eligible`.

Delivery is either a full file upload, which OpenAI's getting started guide recommends daily with API updates between uploads, or API-only for small catalogs. The 2026-04-17 spec adds a push-model Feed API where merchants call agent-hosted endpoints such as `POST /feeds` and `PATCH /feeds/{id}/products` to upsert products.

How you structure and enrich the catalog data itself is a separate problem from the transport, and it is a common source of feed rejections.

The checkout endpoints

This is the part a developer builds. Per OpenAI's Agentic Checkout spec, the merchant hosts five HTTPS endpoints that OpenAI calls:

  1. `POST /checkout_sessions` creates a session from a set of items and returns a priced cart with fulfillment options.
  2. `POST /checkout_sessions/{id}` updates the session when the buyer changes an address, quantity or shipping option, and the merchant recalculates totals.
  3. `GET /checkout_sessions/{id}` returns the current state.
  4. `POST /checkout_sessions/{id}/complete` receives the payment data and creates the order.
  5. `POST /checkout_sessions/{id}/cancel` ends a session that has not completed.

A session moves through `not_ready_for_payment`, `ready_for_payment`, `completed` and `canceled`. Every response returns the full cart state: `line_items` with base amount, discount, subtotal, tax and total, a `totals` breakdown, `fulfillment_options` with costs, a lowercase ISO 4217 `currency`, `messages` for errors and notices, and `links` to your terms, privacy policy and seller policies. The complete call also returns an `order` with an ID and a permalink.

Requests carry an `Authorization` bearer key, an `Idempotency-Key`, a base64 HMAC `Signature` of the body, an `API-Version`, a `Request-Id` and a `Timestamp`. Your responses echo the idempotency key and request ID back.

Order webhooks

After the order exists, the merchant sends events to OpenAI: `order_created` and `order_updated`. The order status values in the spec are created, manual_review, confirmed, canceled, shipped and fulfilled, and refunds are reported with a type of `store_credit` or `original_payment` and an amount in minor units. Webhook payloads are HMAC-signed.

Delegated payment

OpenAI's Delegated Payment Spec defines `POST /agentic_commerce/delegate_payment`, which OpenAI calls on the merchant's payment service provider. The resulting token carries an allowance: a `max_amount` capped at the checkout total, an `expires_at` timestamp, the `merchant_id` and the `checkout_session_id`. A token minted for one session at one merchant cannot be replayed elsewhere or for more money. The request can also carry risk signals with a score and a recommended action (blocked, manual_review or authorized).

Stripe's Shared Payment Token was the first implementation of this spec. PCI DSS Level 1 merchants with their own card vault can implement it directly, though that brings cardholder data into their PCI scope.

How a Single ChatGPT Checkout Worked

The original Instant Checkout flow is the clearest illustration of ACP's mechanics, and it is still the flow the spec describes. Here is one purchase, end to end.

  1. Discovery. A user asks ChatGPT for a product. ChatGPT ranks results from the feeds and third-party data it holds. OpenAI's launch post said Instant Checkout items were not preferred in rankings, though whether checkout was enabled was one of several factors when multiple merchants sold the same product.
  2. Session creation. The user taps Buy. ChatGPT calls your `POST /checkout_sessions` with the item. Your backend validates the SKU, checks stock, and returns a priced cart with shipping options.
  3. Updates. The user confirms or edits their shipping address. ChatGPT calls the update endpoint, and your backend recalculates tax and shipping and returns `ready_for_payment` once nothing is missing.
  4. Confirmation. The user confirms the order in ChatGPT's checkout UI. Nothing is charged until this explicit step.
  5. Token handoff. OpenAI requests a delegated payment token from your PSP, scoped to this session, this merchant and this total, with an expiry.
  6. Completion. ChatGPT calls your `complete` endpoint with the token. You authorize the payment through your PSP as you would any other card transaction, create the order, and return the order ID and permalink. You can also decline.
  7. After the sale. You send `order_created` and later `order_updated` webhooks as the order ships or is refunded. Fulfillment, returns, customer service and chargebacks are yours.

OpenAI's key concepts guide states it directly: OpenAI is not the merchant of record. ChatGPT renders the checkout UI and passes data. Your systems own state, tax, payment and the order.

Status Ledger: What Is Live, Piloting or Announced (October 2026)

Each line gives the program, its status as of October 5, 2026, and the dated source. "Live" means available to real buyers or merchants now. "Limited" means live for an approved set. "Pilot" means real transactions in a controlled program.

OpenAI and ChatGPT

  • ACP specification: live, beta. Latest stable version 2026-04-17. Apache 2.0, maintained by OpenAI and Stripe.
  • ChatGPT Instant Checkout: scaled back. Launched September 29, 2025 for U.S. users buying from U.S. Etsy sellers, with Shopify merchants announced as "coming soon". On March 24, 2026 OpenAI said in Powering Product Discovery in ChatGPT that it would let merchants use their own checkout experiences. OpenAI's shopping help page still says an Instant Checkout option may appear "for some eligible products and merchants".
  • ACP for product discovery: live. Since March 24, 2026, merchants share feeds and promotions through ACP, directly or through providers including Salesforce and Stripe. OpenAI named Target, Sephora, Nordstrom, Lowe's, Best Buy, The Home Depot and Wayfair as integrated for discovery.
  • ChatGPT apps for retailers: live for named partners. Walmart launched an in-ChatGPT app on March 24, 2026 with account linking, loyalty and Walmart payments. OpenAI says merchants who want native experiences can build ChatGPT apps.

Shopify and Etsy

  • Shopify in ChatGPT: live, checkout on merchant site. Per Shopify's ChatGPT help page, buyers complete purchases on the merchant's online store checkout in a ChatGPT in-app browser, or a new tab on ChatGPT web. The store must sell to U.S. customers, though it can be based elsewhere. Shopify says there are no fees for selling in ChatGPT beyond standard payment processing. Shopify's help center lists Microsoft Copilot, not ChatGPT, as an AI channel with built-in checkout.
  • Etsy in ChatGPT: Instant Checkout ended. Etsy was the launch partner in September 2025. Its current presence is an app inside ChatGPT, launched May 5, 2026, that links shoppers through to Etsy to buy.

Stripe

  • Agentic Commerce Suite: live. Launched December 11, 2025. Stripe's seller guide says it is available in the US, Canada and a list of European countries, supports multiple agent protocols, and requires each agent to approve a seller's connection request.
  • ACS custom integration (third-party processor): waitlist, U.S. only. Stripe's custom integration guide is for merchants who host their own checkout endpoints and process on another PSP. Its example request notes checkouts are "currently limited to single item checkouts".

Google

  • Universal Commerce Protocol: live spec; checkout limited. Google published UCP on January 11, 2026, co-developed with Shopify, Etsy, Wayfair, Target and Walmart. Google's Merchant Center help article says the UCP-powered checkout is available "for select merchants at this time", applies to products with eligibility in the United States, Canada and Australia, and requires an interest form. Buyers pay with Google Pay using card numbers stored in Google Wallet, and the merchant remains seller of record, per Google.
  • Agent Payments Protocol (AP2): spec and reference code. Version 0.1.0 was released September 16, 2025 and 0.2.0 on April 28, 2026, per the AP2 repository. It defines how agents prove user authorization for a checkout and a payment. Google lists UCP as compatible with AP2. The public Google merchant documentation reviewed for this article does not require AP2 mandates for any consumer checkout today.

Card networks and wallets

  • Visa Trusted Agent Protocol: live spec. Introduced October 14, 2025 with Cloudflare, per Visa's announcement. Agents sign requests with HTTP Message Signatures so merchants can tell a verified agent from a bot. Available on Visa Developer Center and GitHub.
  • Visa Intelligent Commerce: live in Europe, expanding. On July 2, 2026, Visa said agents were completing live purchases at independent merchant sites across Europe with more than 30 issuing banks, naming lastminute.com, Frasers, Cleverbridge and BrickDepot.
  • Mastercard Agent Pay: live in the U.S. On September 30, 2025, Mastercard said Citi and U.S. Bank cardholders were enabled, with all U.S. cardholders to follow by mid-November 2025, and that Agent Pay could be used on OpenAI's platform following the ACP launch. On September 30, 2026, it began U.S. testing of a score estimating whether a transaction was initiated by an AI agent.
  • PayPal Agent Ready: live for Braintree merchants. PayPal's Agent Ready overview describes ACP support for ChatGPT and UCP support for Google AI Mode and Gemini, without separate integrations for each.

These layers stack rather than compete. Stripe's custom integration guide notes that a resolved Shared Payment Token can carry a Mastercard Agent Pay or Visa Intelligent Commerce token underneath. ACP and UCP define the merchant conversation; the network programs define the credential and the trust signals.

ACP vs MCP vs UCP

The acronyms get blurred, so plainly:

  • MCP (Model Context Protocol) connects a model to tools and data. It says nothing about carts, taxes or payment tokens. ACP's 2026-04-17 release lists MCP among its additions, but the checkout semantics (sessions, totals, tokens, order events) come from ACP itself.
  • ACP defines the merchant-hosted checkout session, order webhooks and delegated payment. It is payment-provider neutral in the spec, with Stripe's token as the first implementation.
  • UCP covers a similar lifecycle (catalog, cart, identity linking, checkout, orders) and can run over REST, MCP or Google's A2A protocol. In Google's surfaces, payment runs through Google Pay rather than a PSP-issued delegated token.
  • AP2 is a payment authorization layer: signed proof of what the user agreed to. It can sit under UCP.
  • Visa TAP and Mastercard Agent Pay sit at the network level and apply regardless of which merchant protocol carried the order.

A merchant who wants both ChatGPT and Google surfaces is looking at two merchant-side protocols, unless a provider such as Stripe's Agentic Commerce Suite or PayPal's Agent Ready translates for them.

The Merchant Implementation Checklist

If you are building ACP support yourself rather than inheriting it from a platform, this is the work.

  1. Apply. OpenAI says direct product feeds are available to approved partners and points merchants to an application at chatgpt.com/merchants. Stripe requires each agent to accept your connection request. Google requires an interest form. None of these is self-serve today.
  2. Check category eligibility. OpenAI's prohibited list covers adult content, age-restricted products such as alcohol, nicotine and gambling, weapons, prescription-only medications, unlicensed financial products and other legally restricted goods. If you sell in those categories, see the high-risk note in the decision section.
  3. Build the feed. Map your catalog to the required fields, one row per variant. Stripe's guidance is to upload product data once a day and inventory and pricing every 15 minutes, and to send price changes immediately because a mismatch between quoted and charged price fails the checkout.
  4. Expose the five checkout endpoints. Each must return a complete, recalculated cart on every call. Treat create and update as quote operations and complete as the only call that writes an order.
  5. Make every write idempotent. OpenAI's production checklist asks you to show that repeated requests with the same key are safe. Agents retry, and a retried `complete` must not create a second order or a second charge. The retry and idempotency patterns in our BFCM checkout performance guide apply directly.
  6. Verify signatures both ways. Validate the HMAC on inbound requests and sign your outbound webhooks.
  7. Meet the network requirements. OpenAI's production checklist requires TLS 1.2 or later on port 443 with a valid public certificate and allowlisting OpenAI's published IP ranges. If you handle delegated payment credentials, OpenAI may require a PCI attestation of compliance before production access.
  8. Choose a PSP that can redeem delegated tokens. Stripe (Shared Payment Tokens), PayPal through Braintree, or your own vault if you are PCI DSS Level 1.
  9. Wire order webhooks into fulfillment. Emit `order_created` on completion and `order_updated` on every status change and refund.
  10. Pass the conformance checks. OpenAI's list includes creating a session with and without an address, changing the shipping option, creating a delegated token, completing with a tokenized payment, emitting webhooks, and demonstrating error handling.

Reality Check: What the Protocol Does Not Solve

You carry the chargeback risk

Every program in the ledger keeps the merchant as merchant of record. That means you also own disputes, including "I didn't authorize that" claims where the buyer says an agent acted outside their instructions. The scoped token limits how much can be charged, but it does not shift liability. If your category already runs hot on disputes, our guide to chargebacks for high-risk brands covers the monitoring thresholds that matter.

You lose browser-side fraud signals

On an ACP complete call, there is no browser session on your site. Device fingerprinting, behavioral scripts and 3-D Secure challenges that run in your checkout page do not run. What you get instead is whatever the agent passes: the delegated payment spec carries optional risk signals, and Stripe's custom integration includes client device metadata such as user agent and IP address. The networks are building replacements (Visa's agent signatures, Mastercard's agent probability score), but in October 2026 several of those are still in testing.

Tax and shipping must be quoted in real time

Every create and update call has to return final tax and shipping. A cached shipping table that is close enough on your site becomes a hard failure in an agent checkout, because the agent shows the user a total and the token is capped at that total. If your tax engine or carrier rating is slow, the agent waits on it.

Promotions, loyalty and multi-item carts were the sticking points

OpenAI's own explanation for scaling back Instant Checkout was flexibility. Stripe's custom integration is still documented as single-item. If your conversion depends on stacked discounts, loyalty redemption, bundles or store pickup, check the current spec version before assuming they map.

Refunds and returns are still yours to run

ACP reports refunds through `order_updated`, but the return itself (label, inspection, restock, refund to original payment or store credit) runs in your systems. The agent does not handle a return conversation for you.

Fees stack

The protocols are free to implement. The transactions are not:

  • OpenAI: the launch post said merchants "pay a small fee on completed purchases". OpenAI has not published the rate. Shopify merchants were reported to pay OpenAI 4% on Instant Checkout orders (PYMNTS, citing The Information), a figure OpenAI never published. With in-chat checkout scaled back it is unclear which flows it applies to now.
  • Shopify in ChatGPT: Shopify states no fee beyond standard payment processing.
  • Stripe: card processing from 2.9% + 30¢ for domestic cards, and Stripe's pricing page lists Shared Payment Tokens at $0.15 per SPT issued. Confirm with Stripe which party is billed for issuance in your flow.
  • Google UCP checkout: Google's help article does not list a fee.
  • Your platform: since June 1, 2026, BigCommerce charges an Open Payment Provider fee of 2.0%, 1.0% or 0.6% of GMV on its Core, Growth and Scale self-serve plans for orders processed outside its embedded payment providers. If an agentic order routes through a non-embedded processor, that fee applies on top of everything above.

Model the full stack per order before you assume agent channels are cheaper than your own checkout.

What an API-First Backend Changes

Look at what the checkout endpoints actually ask for: create a cart from SKUs, set an address, return shipping options and tax, accept a payment, create an order, and report status changes. On an API-first commerce backend, every one of those is already a server-side call. The ACP endpoint becomes an adapter: translate the ACP request into your platform's cart and order calls, translate the response back into ACP's schema, and handle the signature, idempotency and token redemption at the edge.

On a hosted platform where checkout is a page rather than an API, you depend on the vendor shipping the integration and on its terms. Shopify's answer for ChatGPT, for example, is to send the buyer to the merchant's own checkout in an in-app browser. That keeps your customizations, but it is a redirect, not an agent-completed purchase.

Swell is one example of the first model, and it is worth being precise about what exists. Swell does not offer native ACP or UCP support, as our Swell vs Medusa comparison states, and its payments docs do not cover delegated payment tokens. What Swell documents are the primitives an adapter would call:

  • The Backend API is a REST API at `api.swell.store` with JSON request and response bodies, the right surface for server-to-server calls from an ACP endpoint.
  • The carts model carries line items, per-item and cart-level `tax_total`, and a `shipment_rating` object listing available shipping services and rates once a shipping country is set. Converting a cart to an order is a single call that returns an error if required properties are missing or stock is unavailable, which maps cleanly to ACP's decline path.
  • Webhooks fire on model events and retry on failure, which is the hook for emitting ACP `order_updated` events. Swell also documents real-time taxes and shipping webhooks whose responses merge into the cart, useful if your tax or rating logic lives elsewhere.
  • The Frontend API uses a public key and covers storefront carts. It is for your own storefront, not for an ACP adapter, which should use secret-key Backend API calls.

The open question on any platform is the payment step. Swell's payments model documents card tokens from Swell Checkout or Stripe.js. It does not document Shared Payment Tokens, so redeeming an SPT and recording the result against a Swell order is integration work to confirm with Swell before you scope it. If fees come into the comparison, Swell's published pricing runs from Starter at $29 a month to Unlimited at $2,250 a month billed yearly, with trailing-12-month revenue ceilings of $50K, $250K, $1M and $5M and overage beyond the ceiling of 2%, 1.5%, 1% and 0.4%. The overage rate falls as you move up, and stores above $10M a year get custom pricing.

Which Path Fits Your Store

You sell on Shopify. You are likely already discoverable in ChatGPT through Shopify Catalog, and Shopify handles the checkout handoff. Your work is keeping product data clean and your store policies complete. Building ACP endpoints yourself would duplicate what the platform does.

You sell on Etsy or another marketplace. The marketplace owns the integration. Agent sales, if any, come through its app or feed.

You run a custom or headless stack with your own checkout API. You have three options. Feed-only ACP gets you discovered in ChatGPT and sends buyers to your site, and it is the lowest-effort step. Stripe's Agentic Commerce Suite reaches multiple agents with one integration if you process on Stripe and fall within its country list. A direct ACP build gives you the most control and is worth it only once you have been approved by an agent and have volume to justify the conformance and PCI work.

You sell in restricted categories. Nicotine and vape, alcohol, adult products and weapons are named in OpenAI's prohibited products policy, and categories such as CBD or kratom risk the policy's clause on legally restricted goods. Expect to be ineligible for in-agent checkout on mainstream surfaces for the foreseeable future, and put the effort into your own checkout and payment stack instead.

You are B2B or have negotiated pricing. Today's ACP flows assume a consumer, a card and a list price. Account-specific pricing and payment terms do not have a clear mapping yet.

FAQ

Is the Agentic Commerce Protocol open source?

Yes. The specification, OpenAPI files, JSON schemas and examples are published on GitHub under the Apache 2.0 license. OpenAI and Stripe are the founding maintainers, contributions require a signed contributor license agreement, and the spec is still labelled beta.

Do I need Stripe to accept ACP payments?

No. The delegated payment spec is provider neutral. Stripe's Shared Payment Token was the first implementation, PayPal supports ACP for Braintree merchants, and a PCI DSS Level 1 merchant with its own vault can implement the delegated payment endpoint directly. Stripe's custom integration also lets you resolve an SPT and process the payment on a different processor.

Is ChatGPT Instant Checkout still available?

Only in a limited form. OpenAI said on March 24, 2026 that it would let merchants use their own checkout experiences while it focused on discovery. Its shopping help page still mentions an Instant Checkout option for some eligible products and merchants, but Shopify merchants now check out on their own store inside an in-app browser, and Etsy's Instant Checkout integration has ended.

Which countries can use agent checkout today?

It depends on the surface. ChatGPT's Instant Checkout launched for U.S. users and U.S. Etsy sellers. Shopify requires stores selling in ChatGPT to sell to U.S. customers. Google's UCP checkout article covers products eligible in the United States, Canada and Australia. Stripe's Agentic Commerce Suite lists the US, Canada and a set of European countries, while its custom integration is U.S.-only.

How is ACP different from Google's UCP?

Both define how an agent runs a checkout against a merchant backend, and both keep the merchant as the seller of record. ACP came from OpenAI and Stripe and uses a delegated token from the merchant's PSP. UCP came from Google with Shopify and major retailers, can run over REST, MCP or A2A, and in Google's surfaces settles through Google Pay. Stripe and PayPal both support the two.

Can an agent buy from my store without any integration?

Yes, in the sense that a browsing agent can fill in your web checkout like a person would. Google's help center distinguishes its agentic checkout feature, which buys on the merchant's website at the customer's direction, from UCP checkout, which happens on Google's surface. Visa's Trusted Agent Protocol exists so you can tell those verified agents apart from bots.