Brenden Integrations

How to Feed Your Product Catalog to AI for Search, Merch and Purch

by

If you mean ChatGPT’s “Instant Checkout” (buy inside chat), the most efficient path is not sitemap.xml. It’s:

  1. A product feed (your catalog, normalized to OpenAI’s feed schema)
  2. A checkout API (5 HTTPS JSON endpoints)
  3. A delegated-payments path (usually Stripe Shared Payment Token), plus order webhooks
  4. OpenAI certification / conformance
     (OpenAI Developers)

Below is the concrete “what data / what order / what format / what schema”.

Table of Contents

Step 0 — Confirm eligibility and apply

Instant Checkout in ChatGPT is open to approved partners. The official “Get started” flow is: apply → share product feed → implement checkout API + webhooks → implement payments → certify → production.
 (OpenAI Developers)

If you’re already an eligible Etsy or Shopify merchant, OpenAI notes you may not need to apply or build a custom integration.
 (OpenAI Developers)

Step 1 — Product catalog: what to send, format, and cadence

What it is (and what it’s not)

  • This is a dedicated commerce feed, not a crawl-based integration.
  • sitemap.xml + on-page SEO help discovery on the open web, but they do not wire you into Instant Checkout.

Feed format (efficient + supported)

OpenAI’s Product Feed Spec supports compressed feeds (commonly JSONL.gz or CSV.gz) for fast ingestion and frequent refreshes.
 (OpenAI Developers)

The two “switches” that matter

Your feed includes flags that determine whether a product can be:

  • shown for search (enable_search)
  • purchased via checkout (enable_checkout)
     (OpenAI Developers)

Minimum data (practical MVP)

At minimum, plan your pipeline to reliably populate these, per item:

A) Identity + merchandising

  • id (stable SKU / product id)
  • title
  • description
  • link (product URL)
  • image_link (primary image URL)
     (OpenAI Developers)

B) Offer + availability

  • price (with ISO currency)
  • availability (e.g., in_stock / out_of_stock)
  • inventory_quantity (strongly recommended if you run tight inventory)
     (OpenAI Developers)

C) Checkout trust + policy (don’t skip)

  • Store identity and policy URLs (seller name/site, privacy/TOS)
  • Returns: return_policy, return_window
    These are the fields that prevent “great product, can’t safely complete purchase” outcomes.
     (OpenAI Developers)

Strongly recommended (improves ranking + reduces failed checkouts)

  • Shipping/fulfillment metadata (shipping cost hints, delivery windows, carrier text)
  • Tax/fee clarity if your system can estimate at session-time
  • Compliance fields (warning, age_restriction) where relevant
     (OpenAI Developers)

Prohibited / restricted categories

The feed spec includes a prohibited products policy (e.g., certain age-restricted, illegal, or dangerous items). Make sure your catalog filter runs before you export.
 (OpenAI Developers)

Step 2 — Checkout: the API you must implement (5 endpoints)

OpenAI calls your system over HTTPS JSON to create/update/complete sessions, plus cancel/get.
 (OpenAI Developers)

Required endpoints

  • POST /checkout_sessions (create)
  • POST /checkout_sessions/{checkout_session_id} (update)
  • POST /checkout_sessions/{checkout_session_id}/complete (finalize + create order)
  • POST /checkout_sessions/{checkout_session_id}/cancel (optional but supported)
  • GET /checkout_sessions/{checkout_session_id} (fetch session)
     (OpenAI Developers)

Required request/response behavior (what to return every time)

Every response must return a rich, authoritative cart state:

  • line items with computed totals (base, discounts, tax, fulfillment, grand total)
  • available fulfillment options (shipping methods, delivery windows)
  • session status (e.g., ready_for_payment)
  • policy links (ToS / privacy / etc.)
  • messages/errors to show the buyer (out of stock, address invalid, etc.)
     (OpenAI Developers)

Security + robustness (non-negotiable)

Requests include:

  • Authorization: Bearer …
  • Idempotency-Key
  • Signature + Timestamp
  • API-Version
    Build your handler so retries are safe and idempotent.
     (OpenAI Developers)

Step 3 — Order lifecycle: webhooks back to OpenAI

Your system must publish order lifecycle events to the webhook OpenAI provides so ChatGPT stays in sync (created/updated/etc.).
 (OpenAI Developers)

Step 4 — Payments: what to integrate

Typical merchant path (fastest)

Use a PSP that already supports the Delegated Payment flow; OpenAI highlights Stripe’s Shared Payment Token as the first compatible implementation.
 (OpenAI Developers)

Direct delegated payment integration (only if you’re a PSP or PCI DSS Level 1 w/ vault)

The Delegated Payment Spec describes:

  • OpenAI sending a single-use delegated payment payload to the PSP/vault
  • PSP returning a scoped token
  • OpenAI forwarding that token to the merchant during /complete so you can charge using your normal flow
     (OpenAI Developers)

It also defines the PSP endpoint:

  • POST /agentic_commerce/delegate_payment
    with idempotency, signatures, and a constrained “allowance” (max amount + expiry).
     (OpenAI Developers)

“Most efficient” implementation order (do this in this order)

  1. Export feed MVP for ~50–200 best-selling SKUs (with enable_search=1, enable_checkout=1)
  2. Implement POST /checkout_sessions returning full cart state
  3. Implement POST /checkout_sessions/{id} (address + shipping updates)
  4. Implement /complete (create order + take payment token)
  5. Add order webhooks
  6. Expand feed to full catalog + high-frequency refresh
  7. Conformance / certification
     (OpenAI Developers)

Example payloads (starting templates)

JSONL row (one product per line)

{"id":"SKU-123","enable_search":true,"enable_checkout":true,"title":"Acme Widget 2-Pack","description":"Two high-durability widgets.","link":"https://example.com/p/SKU-123","image_link":"https://example.com/i/SKU-123.jpg","price":"19.99 USD","availability":"in_stock","inventory_quantity":42,"brand":"Acme","product_category":"widgets","return_policy":"https://example.com/returns","return_window":30,"seller_name":"Example Store","seller_url":"https://example.com","seller_privacy_policy":"https://example.com/privacy","seller_tos":"https://example.com/terms"}

CSV header (illustrative)

id,enable_search,enable_checkout,title,description,link,image_link,price,availability,inventory_quantity,brand,product_category,return_policy,return_window,seller_name,seller_url,seller_privacy_policy,seller_tos

(Exact optional columns depend on how deep you go into shipping, compliance, reviews, etc.)
 (OpenAI Developers)

Where sitemap.xml / schema.org do fit (optional, but useful)

Use these for general discoverability (not Instant Checkout wiring):

  • sitemap.xml with clean canonical product URLs
  • schema.org Product + Offer markup on product pages
  • consistent SKU/GTIN/MPN on-page (matches feed IDs)

They help when ChatGPT is browsing the web, but Instant Checkout itself is driven by the feed + checkout spec.
 (OpenAI Developers)

Endnotes (official specs to hand your dev team)

  1. Agentic Commerce “Get started” (Instant Checkout onboarding steps)  (OpenAI Developers)
  2. Product Feed Spec (catalog schema + required/recommended fields)  (OpenAI Developers)
  3. Agentic Checkout Spec (required endpoints + request/response schema)  (OpenAI Developers)
  4. Delegated Payment Spec (tokenization / PSP flow)  (OpenAI Developers)

https://developers.openai.com/commerce/specs/feed

https://developers.openai.com/commerce/guides/production

Tech guide: link your product catalog to ChatGPT “Instant Checkout” (Agentic Commerce Protocol)

If you want Instant Checkout inside ChatGPT, you integrate via the Agentic Commerce Protocol (ACP) and (today) you also apply to be enabled. ACP is open to build against, but Instant Checkout access is currently for approved partners. (OpenAI Developers)

The most efficient path (order of operations)

  1. Merchant signup / apply
  1. Publish your catalog via the Product Feed Spec
  1. Implement the Agentic Checkout API (your “instant checkout” endpoints)
  1. Payments integration (Delegated Payment or Stripe’s Shared Payment Token path)
  1. Conformance / production readiness

1) Product catalog: what data, what format, how delivered

Delivery mechanism (it’s not a sitemap)

You don’t “submit a sitemap.xml” for Instant Checkout. The canonical integration is a merchant-pushed product feed to an allow-listed HTTPS endpoint / secure transfer location, on an agreed delivery setup. (OpenAI Developers)

File formats (supported)

  • jsonl.gz (gzip-compressed JSON Lines)
  • csv.gz (gzip-compressed CSV) (OpenAI Developers)

Update cadence

Schema: the Product Feed Spec (required fields you should plan around)

Below are the fields that matter most for getting a product discoverable and (if approved) purchasable in ChatGPT.

A) OpenAI control flags (required)

  • enable_search = true|false (required)
  • enable_checkout = true|false (required; enable_search must be true to enable checkout) (OpenAI Developers)

B) Basic product identity (required)

  • id (stable, unique product ID; required)
  • title (required)
  • description (required)
  • link (required product page URL that resolves; HTTPS preferred) (OpenAI Developers)
    Plus identifiers:
  • gtin (recommended)
  • mpn (required if gtin is missing) (OpenAI Developers)

C) Classification & physical info (expect to provide these)

  • product_category (required; uses “>” separators)
  • brand (required for most items; exceptions called out in the spec)
  • material (required)
  • weight (required; number + unit) (OpenAI Developers)

D) Media (required)

  • image_link (required; JPEG/PNG; HTTPS preferred)
  • additional_image_link (optional) (OpenAI Developers)

E) Pricing (required)

  • price (required; number + ISO currency, e.g., 79.99 USD)
  • sale_price + sale_price_effective_date (optional, with constraints) (OpenAI Developers)

F) Availability & inventory (required)

  • availability (in_stock|out_of_stock|preorder) (required)
  • inventory_quantity (required)
  • availability_date (required if preorder) (OpenAI Developers)

G) Variants (required if you have variants)

  • item_group_id (required if variants exist)
  • plus recommended variant descriptors like color, size, size_system, etc. (OpenAI Developers)

H) Fulfillment (shipping)

  • shipping (required “where applicable”, formatted like US:CA:Overnight:16.00 USD) (OpenAI Developers)

I) Merchant policies / trust fields (these become critical for checkout)

  • seller_name (required)
  • seller_url (required)
  • seller_privacy_policy (required if enable_checkout is true)
  • seller_tos (required if enable_checkout is true) (OpenAI Developers)

J) Returns (required)

  • return_policy (required URL)
  • return_window (required integer days) (OpenAI Developers)

K) Strongly recommended enrichment (ranking + conversion)

  • review aggregates (product_review_count, product_review_rating)
  • compliance signals (warning / warning_url, age_restriction)
  • performance signals (popularity_score, return_rate)
  • related products (related_product_id, relationship_type) (OpenAI Developers)

2) “Instant Checkout” API: what endpoints, what request/response shape

To support Instant Checkout, you implement the Agentic Checkout Spec (REST + webhooks). (OpenAI Developers)
Spec URL:  https://developers.openai.com/commerce/specs/checkout/

Required REST endpoints (merchant implements)

  • POST /checkout_sessions (create a checkout session)
  • POST /checkout_sessions/{checkout_session_id} (update session as user changes shipping/items/etc.)
  • POST /checkout_sessions/{checkout_session_id}/complete (finalize: you create the order and process payment)
  • Optional but supported:
  • POST /checkout_sessions/{checkout_session_id}/cancel
  • GET /checkout_sessions/{checkout_session_id} (OpenAI Developers)

Webhooks (merchant emits order lifecycle events)

Your system publishes order lifecycle events to keep ChatGPT in sync (e.g., order created/updated). (OpenAI Developers)

Common requirements: HTTPS + JSON + specific headers

Every endpoint call includes headers like:

  • Authorization: Bearer ...
  • Idempotency-Key: ...
  • Request-Id: ...
  • Signature: ... (base64 signature of request body)
  • Timestamp: ... (RFC3339)
  • API-Version: 2025-09-12 (OpenAI Developers)

What ChatGPT expects back each time (the “rich cart state” rule)

Each response should return a complete, authoritative checkout session state: items, pricing, taxes/fees, shipping options, totals, status, and user-facing messages/errors. (OpenAI Developers)

3) Payments: how “Instant Checkout” avoids you handling card data directly

Payments remain on your rails (you stay merchant of record). The ACP payment mechanism uses Delegated Payment concepts; many merchants will implement via a PSP rather than directly handling cardholder data. (OpenAI Developers)

Key docs:

4) Where sitemap.xml and Schema.org fit (and where they don’t)

  • Sitemaps and Schema.org are not the Instant Checkout integration.
  • They can still help with general web discoverability, but for ChatGPT shopping + Instant Checkout, the authoritative integration is the Product Feed Spec + Agentic Checkout Spec. (OpenAI Developers)

Reference URLs (expanded)

How to Feed Your Product Catalog to AI for Search, Merch and Purch - Brenden Integrations

Visited 8 times, 3 visit(s) today

Leave a Comment