Branch8

Agentic Commerce Protocol ChatGPT Checkout: APAC Build Guide

Matt Li
November 21, 2026
16 mins read
Agentic Commerce Protocol ChatGPT Checkout: APAC Build Guide - Hero Image

Key Takeaways

  • Build an agent-readable commerce layer, not a ChatGPT-specific integration.
  • ACP delegated payment tokens assume card rails — a real APAC constraint.
  • Feed accuracy and real-time availability drive inclusion more than anything else.
  • Land agent orders in your existing OMS; never fork the order model.
  • Measure contribution margin per agent order, not channel GMV.

Quick Answer: The Agentic Commerce Protocol is an open OpenAI–Stripe spec with two parts: a product feed for discovery and merchant-hosted checkout endpoints the agent calls. You stay merchant of record, receive a delegated payment token at completion, and emit order webhooks back to the agent.


Most of the coverage of agentic commerce protocol ChatGPT checkout treats it as a marketing channel launch. It isn't. It's a procurement API that happens to have a consumer chat interface bolted to the front of it, and if you build for the interface instead of the API, you will have wasted a quarter.

Here's the evidence for that view. OpenAI launched Instant Checkout on 29 September 2025 with Etsy sellers, promising over a million Shopify merchants next (OpenAI's own announcement). By early 2026, Digital Commerce 360 reported OpenAI had shifted emphasis toward retailer apps inside ChatGPT rather than a broad Instant Checkout rollout, with Rye's teardown noting only around a dozen merchants had actually gone live. Anyone who built a ChatGPT-shaped integration got a channel that didn't scale on schedule. Anyone who built an agent-readable commerce layer — clean feed, stateless checkout session API, token-based payment delegation, webhook-driven fulfillment — now has something that serves ChatGPT, Google's Agent Payments Protocol, Perplexity, and whatever the Chinese and Southeast Asian super-apps ship next.

Related reading: Shopify Plus Enterprise Fit & Cost Comparison for APAC Brands

Related reading: Salesforce OAuth Token Security Breach Mitigation for APAC Teams

That's the frame for this guide. We build the layer, not the channel. And for teams in Hong Kong, Singapore, Taipei, Sydney or Auckland — or global brands running their APAC operations out of those hubs — there are specific constraints the US-centric documentation simply doesn't address: wallet-dominant payments, e-invoicing mandates, Traditional Chinese product data, and cross-border tax thresholds.

Related reading: Salesforce CRM OAuth Security Incident Response: APAC Playbook

Related reading: Boston Dynamics Acquisition: Robotics Automation Lessons for APAC

What the Agentic Commerce Protocol Actually Specifies

The Agentic Commerce Protocol (ACP) is an open specification co-developed by OpenAI and Stripe, published under an open licence so that any agent and any merchant can speak it without a bilateral contract. Stripe's launch post describes it as an open standard rather than a Stripe product — a point worth noting, because you do not need Stripe to implement it.

It has two halves:

Product feed specification. A structured catalogue you publish so agents can discover, rank and quote your products. Field semantics borrow heavily from Google Merchant Center conventions — id, title, description, price, availability, gtin, item_group_id — plus agent-specific flags controlling whether an item is searchable, purchasable, or both.

Checkout specification (delegated payments). A set of REST endpoints you host, which the agent calls to create and update a checkout session, then complete it. Payment arrives as a delegated token — a single-use credential scoped to one transaction — rather than a raw card number. You remain the merchant of record. You set the price, own the customer relationship, handle fulfillment, and absorb the chargebacks.

The critical architectural fact: the agent calls you, not the other way around. This inverts the usual marketplace integration, where you push orders into someone else's system and poll for status. Under ACP, your checkout API is the system of record for pricing, tax, shipping and availability. If your inventory feed lies, the agent quotes a price you can't honour, and the failure surfaces in a conversation you can't see.

Prerequisites: What You Need Before Writing Any Code

Skip this section and you will discover the gaps during integration testing, which is the most expensive place to find them.

You need a decision on fee tolerance. OpenAI has stated merchants pay a fee on completed purchases, with no price impact to the user — meaning the fee comes out of your margin, not the basket. For a category running 15% contribution margin, an agent channel fee plus payment processing is a material haircut. Run that number before engineering time, not after. For a listed Greater China jewellery retailer we worked with, the equivalent arithmetic on marketplace commissions was the single factor that determined which SKU tiers were exposed to a channel at all. Low-AOV accessories cleared the hurdle; high-touch bridal did not.

You also need clarity on merchant-of-record status across your selling jurisdictions. If a Singapore entity sells into Australia via an agent, you are the one who owes GST treatment, not OpenAI.

Technical readiness

  • A real-time availability source. Not a nightly export. The checkout session endpoints must return accurate stock at call time, because the agent will quote on your response.
  • Deterministic tax and shipping calculation via API. Spreadsheet-driven shipping tables don't work when a machine asks for a quote on a Kowloon address at 02:00.
  • A PSP that supports delegated payment tokens or your own PCI-compliant vault. Stripe supports shared payment tokens natively; Adyen, Airwallex and local acquirers each have their own position on network tokenisation — confirm before committing.
  • Idempotency throughout your order creation path. Agents retry. Aggressively.
  • Webhook infrastructure you can sign and replay. Order status updates flow back out from you.

Operational readiness

This is the part teams underestimate. An agent order arrives with no human in the loop. There is no "we emailed the customer to confirm the address" fallback. The order must be complete, fulfillable and correctly costed at the moment of creation, or it fails hard. Your fulfillment team needs an exception queue that distinguishes agent-originated orders — because the remediation path is different when there's no customer service thread to reply to.

Ready to Transform Your Ecommerce Operations?

Branch8 specializes in ecommerce platform implementation and AI-powered automation solutions. Contact us today to discuss your ecommerce automation strategy.

Step 1: Choose Your Integration Posture

Platform-mediated versus direct protocol implementation

Three routes exist, and the choice is mostly about where you want your engineering risk.

Route A — platform-mediated. Shopify, and increasingly other platforms, handle the ACP surface on your behalf. You enable a toggle, ensure your catalogue is clean, and the platform hosts the endpoints. Fastest path; least control over tax edge cases, bundle logic and B2B pricing. For most DTC brands in APAC running Shopify Plus, this is the correct answer.

Related reading: B2B Ecommerce Development Partner Selection: A Buyer's Guide

Route B — framework implementation. Open-source commerce frameworks now ship ACP support directly; Medusa's documentation includes a tutorial for implementing the Agentic Commerce specifications end to end. You get the endpoint scaffolding and own the business logic. Good for teams already on a headless stack.

Route C — direct implementation against the spec. You build the endpoints yourself. Necessary if your pricing is contract-based, your inventory is distributed across multi-country 3PLs, or you sell through a dealer network where order routing depends on territory. This is also the only route that gives you one checkout layer serving multiple agent protocols.

How to decide in one question

Ask: does my price depend on who is asking? If the answer is yes — dealer tiers, B2B contract rates, membership pricing, duty-inclusive versus duty-exclusive by destination — go direct. Platform-mediated checkout assumes a published price. If the answer is no, take the platform route and spend the saved engineering budget on feed quality, which matters more than you think.

Scope the SKU set deliberately

Do not expose the full catalogue on day one. Pick a subset where stock accuracy is highest, margin tolerates the fee, packaging is standard, and returns are rare. Consumables, standard-size apparel in a single colourway, and sealed-box electronics accessories work well. Made-to-order, perishables, and anything requiring size consultation do not.

Step 2: Make the Product Feed Agent-Readable

Structure over prose

Agents do not read your brand story. They parse attributes and compare. A minimal, well-formed item looks roughly like this:

1{
2 "id": "SKU-8821-BLK-M",
3 "item_group_id": "SKU-8821",
4 "title": "Merino Crew Knit — Black, M",
5 "description": "19.5 micron merino wool crew neck. Machine washable. Fits true to size.",
6 "link": "https://example.com/p/merino-crew?variant=8821-blk-m",
7 "price": { "amount": 89000, "currency": "HKD" },
8 "availability": "in_stock",
9 "inventory_quantity": 42,
10 "gtin": "09501101530003",
11 "brand": "Example",
12 "condition": "new",
13 "shipping": [
14 { "country": "HK", "service": "standard", "price": { "amount": 0, "currency": "HKD" } },
15 { "country": "SG", "service": "standard", "price": { "amount": 12000, "currency": "HKD" } }
16 ],
17 "enable_search": true,
18 "enable_checkout": true
19}

Note the minor-unit integer pricing. Floating-point currency in a feed consumed by an LLM-mediated pipeline is a rounding bug waiting to happen, particularly across JPY and KRW which have no minor unit.

From what's observable in how shopping agents construct comparisons, the fields that drive inclusion are: accurate availability, a resolvable gtin, explicit size and fit language in the description, return policy terms, and shipping cost to the user's country. Baymard Institute's long-running checkout research consistently finds unexpected shipping and delivery cost as the leading cause of cart abandonment at roughly 70% documented average abandonment — agents apply the same filter earlier and more ruthlessly, because they can compare five merchants in one turn.

If your feed omits shipping to Australia, an agent serving an Australian buyer has no reason to surface you.

Multilingual and multi-market feeds

For APAC this is non-trivial. A Traditional Chinese feed for Taiwan and Hong Kong, Simplified for cross-border mainland channels, English for Singapore and Australia — and they are not machine translations of each other. Product naming conventions differ: a Taiwanese shopper searches 針織衫, a Hong Kong shopper may search in mixed script. Publish separate feeds keyed by locale and currency rather than a single feed with translated fields, and keep item_group_id stable across them so variant relationships survive.

Also: normalise addresses. Hong Kong has no postal code. Singapore's six-digit code is mandatory. Japanese addresses run large-to-small. Your feed's shipping configuration and your checkout endpoint's address validation must agree on this, or quotes will fail at session update.

Ready to Transform Your Ecommerce Operations?

Branch8 specializes in ecommerce platform implementation and AI-powered automation solutions. Contact us today to discuss your ecommerce automation strategy.

Step 3: Implement the Checkout Session Endpoints

The endpoint surface

The checkout spec defines a small, stateless-ish REST surface that you host. In practice you implement:

1POST /checkout_sessions # create, return quote
2POST /checkout_sessions/{id} # update (address, shipping option, items)
3GET /checkout_sessions/{id} # retrieve current state
4POST /checkout_sessions/{id}/complete # finalise with delegated payment token
5POST /checkout_sessions/{id}/cancel # abandon

Every call carries authentication, an idempotency key, a request ID for tracing, an API version header, and a signature over the raw body. A create request from an agent looks approximately like:

1curl -X POST https://api.example.com/checkout_sessions \
2 -H "Authorization: Bearer $AGENT_TOKEN" \
3 -H "Content-Type: application/json" \
4 -H "Idempotency-Key: 9d1f3c7a-0b2e-4f55-9a1c-7e2b8c441aa1" \
5 -H "Request-Id: req_01HQ..." \
6 -H "API-Version: 2025-09-29" \
7 -d '{
8 "items": [{ "id": "SKU-8821-BLK-M", "quantity": 1 }],
9 "buyer": { "email": "[email protected]" },
10 "fulfillment_address": {
11 "name": "Chan Tai Man",
12 "line_one": "Flat 12B, 88 Nathan Road",
13 "city": "Kowloon",
14 "country": "HK"
15 }
16 }'

Your response must return the full computed state: line items with resolved prices, available fulfillment options with costs and delivery estimates, tax, total, and a status. The agent renders that. If your totals don't reconcile — subtotal plus shipping plus tax not equalling total to the cent — expect rejection.

Treat the session as a quote with a lifetime

A session is an offer. Offers expire. Set and return an explicit expiry, and decide your reservation policy: do you soft-hold inventory on session create, or only at complete? Holding on create protects conversion and leaks stock to abandoned sessions. Holding only at complete risks overselling between quote and payment.

Our position for most APAC clients: soft-hold on create with a short TTL (10–15 minutes), released automatically, with the hold recorded in the same ledger your web checkout uses. Running two separate reservation systems is how you oversell your best-selling SKU on a Saturday.

1# Illustrative: single reservation ledger shared by web and agent channels
2def reserve(sku, qty, channel, session_id, ttl_seconds=900):
3 with db.transaction():
4 available = db.atp(sku) # available-to-promise, net of holds
5 if available < qty:
6 raise OutOfStock(sku, available)
7 db.insert_hold(sku=sku, qty=qty, channel=channel,
8 ref=session_id, expires_at=now() + ttl_seconds)
9 return True

Error semantics matter more than happy path

When something is wrong, return structured, machine-actionable errors — field-level, with the offending path and a recoverable action — not a 500 with an HTML error page. An agent that receives {"type":"invalid_request","param":"fulfillment_address.postal_code","message":"required for SG"} can ask the user for a postcode. An agent that receives a stack trace abandons the purchase silently.

Keep it idempotent and replay-safe

Store the idempotency key with the computed response, keyed by endpoint and request fingerprint, and return the stored response on replay. Twenty-four hours of retention is a sane default. Without this, a retried complete call creates two orders, two shipments and one very annoyed fulfillment lead.

Step 4: Handle Delegated Payment Tokens — and the APAC Wallet Problem

How delegation works

At complete, the agent hands you a delegated payment credential rather than card data. You present that token to your PSP as you would a saved payment method, and charge it for the session total. You never touch a PAN, which keeps your PCI scope where it already is.

1curl -X POST https://api.example.com/checkout_sessions/cs_01HQ.../complete \
2 -H "Authorization: Bearer $AGENT_TOKEN" \
3 -H "Idempotency-Key: 5a7b..." \
4 -d '{
5 "payment_data": {
6 "token": "spt_1QxYz...",
7 "provider": "stripe",
8 "billing_address": { "country": "HK" }
9 }
10 }'

Capture semantics are your decision: authorise at complete and capture at dispatch is the safer pattern for anything shipping from a 3PL, because it avoids refund churn on stock exceptions.

The constraint nobody in the US documentation mentions

Delegated payment tokens, as currently specified and deployed, assume card rails. That assumption breaks across most of Asia-Pacific. Worldpay's Global Payments Report has consistently shown digital wallets as the dominant e-commerce payment method in the region by transaction value, well ahead of cards — Alipay and WeChat Pay in Greater China, PayMe and FPS in Hong Kong, PayNow in Singapore, GrabPay and regional wallets across Southeast Asia, Konbini and carrier billing in Japan.

None of those are presently expressible as a delegated card token. So the honest implementation position is:

  • Agent checkout in APAC is, for now, a card-paying-customer channel. That skews toward higher-income, cross-border and expatriate segments, and toward Australia and New Zealand where card penetration is high.
  • Build a fallback handoff. Where the buyer's preferred method isn't tokenisable, return a checkout URL from your session so the agent can hand off to your hosted checkout. You lose the in-conversation completion, but you keep the order. This is also the pragmatic answer to "agentic commerce protocol ChatGPT checkout URL" queries — the URL handoff is a legitimate part of the design, not a failure state.
  • Don't rebuild wallet support as a bespoke extension. The protocol will extend, or regional equivalents will emerge. Visa's Intelligent Commerce and Mastercard's Agent Pay initiatives, both announced during 2025, are the card networks' answer; Google's Agent Payments Protocol (AP2), launched in September 2025 with a stated 60-plus launch partners, is explicitly designed to be payment-method-agnostic. Keep your payment layer abstracted behind an interface so you can add rails without touching session logic.

Refunds, disputes and who eats them

You are the merchant of record. Chargebacks land on you. An agent-mediated purchase where the buyer never saw your product page is, in dispute terms, a weaker position than a conventional web order — you have less evidence of what was shown. Keep a full audit of every session: the item snapshot you returned, the price, the shipping terms, timestamps, and the agent's request IDs. That record is your dispute defence.

Ready to Transform Your Ecommerce Operations?

Branch8 specializes in ecommerce platform implementation and AI-powered automation solutions. Contact us today to discuss your ecommerce automation strategy.

Step 5: Sign, Version and Secure the Integration

Verify signatures on raw bytes

The spec requires request signing. The implementation detail that trips teams up: verify against the raw request body, before any JSON parsing or middleware re-serialisation. Express's express.json() will happily reorder nothing but will hand you a parsed object whose re-stringification differs from the original byte sequence.

1// Express: capture raw body for signature verification
2app.use(express.json({
3 verify: (req, _res, buf) => { req.rawBody = buf; }
4}));
5
6function verifyAgentSignature(req) {
7 const signature = req.get('Signature');
8 const timestamp = req.get('Timestamp');
9 if (!signature || !timestamp) return false;
10
11 // Reject stale requests to blunt replay attacks
12 const skew = Math.abs(Date.now() / 1000 - Number(timestamp));
13 if (skew > 300) return false;
14
15 return verifyPerSpec({
16 payload: req.rawBody, // raw bytes, not JSON.stringify(req.body)
17 timestamp,
18 signature,
19 publicKey: process.env.AGENT_PUBLIC_KEY
20 });
21}

Follow the current ACP specification for the exact algorithm and canonicalisation rules — they are versioned and have changed since the initial release. Hard-coding last quarter's assumption is how integrations silently break.

Pin the API version and handle deprecation

Every request carries an API version header. Log it. Alert when you see a version you don't recognise, rather than coercing it into your current handler. The protocol is young and moving; OpenAI's shift in rollout strategy during late 2025 and early 2026, as reported by Digital Commerce 360, is a reasonable indicator that surface changes will continue.

Rate limiting and abuse

Agents are efficient catalogue scrapers. Rate-limit session creation per credential, and monitor the ratio of sessions created to sessions completed. A sharp drop in that ratio usually means either a pricing or availability bug in your feed, or someone using your quote endpoint as a free price oracle.

Step 6: Wire Agent Orders Into Fulfillment Automation

This is where the operational automation value actually sits, and where most published guides stop.

Normalise agent orders into one order model

Resist the temptation to create a parallel "agent orders" table. Land them in the same OMS as web, marketplace and retail orders, with a channel attribute and the agent's request IDs preserved. Everything downstream — allocation, pick-pack, carrier selection, returns — then works without modification. Teams that fork the order model end up maintaining two fulfillment code paths forever.

For a Hong Kong multi-brand catering group running several fulfillment nodes, the single-order-model discipline was what made adding each new channel a configuration change rather than a project. The same logic applies here.

Push status back via webhooks

ACP expects you to emit order lifecycle events so the agent can keep the buyer informed without a support ticket. At minimum:

1{
2 "type": "order_update",
3 "data": {
4 "checkout_session_id": "cs_01HQ...",
5 "permalink_url": "https://example.com/orders/1042817",
6 "status": "shipped",
7 "fulfillments": [{
8 "carrier": "sf_express",
9 "tracking_number": "SF1234567890",
10 "tracking_url": "https://www.sf-express.com/...",
11 "shipped_at": "2026-02-11T03:14:00Z"
12 }]
13 }
14}

Wire this to your WMS or 3PL event stream, not to a human clicking a button. If your 3PL in Shenzhen or Port Klang only produces a nightly CSV, that latency becomes the buyer's experience. Fixing 3PL event latency is often the highest-leverage work in the whole integration, and it has nothing to do with the protocol.

Build an exception queue specifically for agent orders

Agent orders fail differently. The common cases: address that passes format validation but fails carrier serviceability (Hong Kong outlying islands, Australian remote postcodes), item that was in stock at quote and gone at pick, and restricted-goods conflicts on cross-border lanes. Each needs an automated resolution path — substitute, partial-ship, or cancel-and-refund with an emitted event — because there is no email thread to fall back on.

Route these to a queue with an SLA measured in minutes, not the general customer service inbox. Tag them so you can measure the exception rate per channel; if agent orders throw exceptions at several times the rate of web orders, your feed accuracy is the root cause, not your operations team.

Instrument the funnel you cannot see

You get no session recording, no heatmap, no referrer path. What you do get: session create volume, update frequency, which fields triggered errors, completion rate, and time-to-complete. Build a dashboard on those five metrics before launch. Adobe Analytics has reported generative-AI referral traffic to US retail sites growing by an order of magnitude year on year — if that pattern repeats across APAC, you will want baseline measurement already running when the volume arrives.

Ready to Transform Your Ecommerce Operations?

Branch8 specializes in ecommerce platform implementation and AI-powered automation solutions. Contact us today to discuss your ecommerce automation strategy.

Step 7: Resolve Tax, Invoicing and Cross-Border Before Launch

Your checkout endpoint owns tax calculation

The agent will not compute tax. Whatever your session response returns is what the buyer is charged. For APAC sellers this means:

  • Singapore GST under the Overseas Vendor Registration regime applies to low-value imported goods sold to Singapore consumers once registration thresholds are met — your endpoint must apply it based on destination, not on your entity's location.
  • Australia GST applies to low-value imported goods supplied to Australian consumers; the ATO's rules put the obligation on the supplier or the electronic distribution platform. Determine which you are.
  • Hong Kong has no GST/VAT, which makes HK a clean origin for cross-border agent sales and is part of why it remains a sensible hub for regional DTC operations.

Get these codified in an API your checkout endpoint calls. A tax matrix in a spreadsheet cannot respond to a machine in 300 milliseconds.

Taiwan e-invoice and other local mandates

Taiwan's unified invoice (統一發票) requirement means a completed sale must issue a government e-invoice, and buyers frequently expect to supply a carrier barcode or company tax ID. The current ACP buyer object has no natural field for that. Your options: capture it post-purchase via the order permalink, default to a member carrier, or exclude Taiwan from the agent channel until the protocol accommodates custom buyer fields. Pick deliberately — discovering this after your first Taiwanese order is an accounting problem, not an engineering one.

Similar considerations apply elsewhere: Korean customs requires a personal clearance code for imports; Indonesian and Philippine lanes have their own documentation requirements. The pattern is the same — agent checkout collects a minimal buyer profile, and any jurisdiction demanding more than that needs either a post-purchase capture flow or exclusion.

Duty-inclusive pricing or clear disclosure

If an agent quotes a total and the buyer later receives a duty invoice at the door, your dispute rate and your review sentiment both suffer. Either land duty-paid (DDP) and include it in the quoted total, or state the exclusion explicitly in the fulfillment option description. Ambiguity is the one option that fails.

Step 8: Test, Launch Narrow, and Measure Honestly

Build a conformance harness

Before requesting production access, exercise your endpoints against the spec yourself: out-of-stock at complete, expired session, address change triggering a shipping cost change, idempotent replay of complete, malformed signature, unknown API version, currency with no minor unit, and a multi-item order where one line is restricted in the destination country. Script all of these. Each one will happen in production within the first month.

Launch on a narrow SKU set in one or two markets

Start with the markets where card payment is dominant and your fulfillment is strongest — typically Australia, New Zealand, Singapore and Hong Kong for APAC-based sellers. Hold the SKU set small enough that a human can audit every feed row. Expand on measured exception rate, not on enthusiasm.

Define success in margin terms, not GMV

The metric that matters is contribution margin per agent order after channel fee, payment cost, shipping and the exception-handling labour. GMV through a new channel is easy to generate and easy to misread. If agent orders carry a higher return rate — plausible, given the buyer never saw a product page — that shows up in margin and nowhere else.

Be equally honest about volume. OpenAI reported ChatGPT serving around 800 million weekly users as of its October 2025 DevDay, which is a large top-of-funnel number and tells you nothing about how many of them will complete a purchase in-conversation in your category, in your market, this year.

Ready to Transform Your Ecommerce Operations?

Branch8 specializes in ecommerce platform implementation and AI-powered automation solutions. Contact us today to discuss your ecommerce automation strategy.

Common Mistakes and How to Diagnose Them

Feed and discovery failures

Symptom: your products never appear in agent recommendations. Usual causes, in order of frequency: missing or incorrect gtin; availability stale because the feed is generated nightly; no shipping entry for the buyer's country; price in a currency the agent cannot convert confidently; marketing prose where attributes should be. Fix the feed before suspecting the algorithm.

Symptom: products appear but are never chosen. Check your delivered cost and delivery estimate against two competitors in the same destination. Agents optimise on landed cost and speed far more consistently than humans do.

Session and checkout failures

Symptom: sessions create but never complete. Instrument which update call errors. The most common culprits we see are address validation rejecting valid Hong Kong addresses for want of a postal code, and shipping options returning empty for destinations your carrier configuration doesn't cover.

Symptom: totals rejected. Reconcile subtotal + shipping + tax + adjustments against your returned total in minor units, with no floating-point arithmetic anywhere in the path. Rounding discrepancies of one cent will fail validation.

Symptom: duplicate orders. Your idempotency store isn't being consulted on complete, or it's keyed on the request body hash rather than the supplied key. Fix the key strategy.

Symptom: signature verification fails intermittently. Almost always body mutation by middleware, or clock skew on your servers. Check NTP, then check your raw-body capture.

Organisational mistakes

Treating it as a marketing project. The work is 20% feed, 30% checkout API, and 50% fulfillment operations. Staff it accordingly.

Building channel-specific logic. If if (channel === 'chatgpt') appears in your order processing code, you have built a ChatGPT integration rather than an agentic commerce capability. The next protocol — AP2, a card network scheme, or a regional super-app equivalent — will require a second integration.

Exposing the full catalogue immediately. Every inaccurate row in a 40,000-SKU feed is a potential failed order that you cannot see failing.

Assuming the channel will scale on the vendor's original timeline. It may not; the 2025–26 Instant Checkout rollout is the case study. Build the layer because agent-mediated purchasing is directionally real across multiple vendors, and size the investment so that a slower rollout is survivable rather than a write-off.

The durable position on agentic commerce protocol ChatGPT checkout is unglamorous: a clean feed, an honest real-time availability signal, a stateless checkout API with proper idempotency, abstracted payment rails, and fulfillment events that fire without human intervention. Every one of those assets pays for itself in your existing channels whether or not agent volume materialises. That is the only version of this bet that doesn't depend on someone else's product roadmap.

If you're scoping an agent-readable commerce layer for APAC — multi-currency, multi-locale, with 3PL event plumbing that actually works — Branch8's team builds and operates exactly this stack across Hong Kong, Singapore, Taiwan and Australia. Talk to us about your integration.

Sources

FAQ

The Agentic Commerce Protocol (ACP) is an open specification co-developed by OpenAI and Stripe that defines how an AI agent discovers products and completes a purchase with a merchant. It has two parts: a product feed specification for discovery, and a checkout specification of REST endpoints the merchant hosts. When a buyer orders in ChatGPT, the agent calls those endpoints and passes a delegated payment token, with the merchant remaining the merchant of record.

About the Author

Matt Li

Co-Founder & CEO, Branch8 & Second Talent

Matt Li is Co-Founder and CEO of Branch8, a Y Combinator-backed (S15) Adobe Solution Partner and e-commerce consultancy headquartered in Hong Kong, and Co-Founder of Second Talent, a global tech hiring platform ranked #1 in Global Hiring on G2. With 12 years of experience in e-commerce strategy, platform implementation, and digital operations, he has led delivery of Adobe Commerce Cloud projects for enterprise clients including Chow Sang Sang, HomePlus (HKBN), Maxim's, Hong Kong International Airport, Hotai/Toyota, and Evisu. Prior to founding Branch8, Matt served as Vice President of Mid-Market Enterprises at HSBC. He serves as Vice Chairman of the Hong Kong E-Commerce Business Association (HKEBA). A self-taught software engineer, Matt graduated from the University of Toronto with a Bachelor of Commerce in Finance and Economics.