Skip to content
Climb Google Maps: Google Business Profile optimization.

AI Search

ChatGPT Wallet Lets OpenAI's Agents Pay on Your Store. Check Your Bot Settings Before They Fail at Checkout

OpenAI launched ChatGPT Wallet on Nov. 13, letting its dots agents buy from ordinary websites with a card token and the shopper's fingerprint or Face ID. Merchants don't need to integrate anything, but OpenAI's own docs warn that bot protection and fraud rules can make those purchases fail. Here is what to check, and a script that verifies ChatGPT's signed requests.

A shopper holding a payment card while typing on a laptop at a wooden desk

Key takeaways

  • OpenAI launched ChatGPT Wallet on Nov. 13, 2026, so its dots agents can complete purchases on ordinary websites after the shopper approves each one with Face ID or a fingerprint.
  • TechCrunch reports the first rollout is limited to some US ChatGPT Pro subscribers aged 18 and over with US-issued cards; OpenAI has not announced other countries.
  • OpenAI's merchant docs say Wallet needs no integration, but bot protection and fraud systems can block ChatGPT's cloud browser and make purchases fail.
  • Akamai, Cloudflare, HUMAN and Vercel verify ChatGPT request signatures automatically; on Cloudflare the agent appears as "dots, OpenAI" under Personal Agents.
  • We verified the Ed25519 signature on ChatGPT's public key directory on Nov. 15, 2026 with a short Node script and no packages; a site on another firewall can check signed agent requests the same way.

OpenAI launched ChatGPT Wallet on Nov. 13, 2026. It lets the agents in ChatGPT, which OpenAI calls dots, pay for things on ordinary websites: the shopper saves a card once, the agent fills the cart and checkout, and the shopper approves each purchase with Face ID or a fingerprint before it goes through.

If you sell online, the part that matters is on your side. OpenAI's developer docs say Wallet "works out of the box" with existing checkout pages, with no integration. The same docs warn that bot protection and fraud systems can block ChatGPT's browser by accident "and cause purchases to fail." So the work this week is a settings check, not a build.

What launched, and where it works

OpenAI's announcement describes Wallet as a way for agents in ChatGPT Work, Codex and dots to complete purchases "with user approval and existing card protections." According to TechCrunch's report of the launch:

  • The first rollout is limited to some US ChatGPT Pro subscribers, aged 18 and over, with US-issued Visa, Mastercard or American Express cards.
  • Wallet pays with a payment token instead of the card number, so neither the agent nor the merchant sees the real card details.
  • Before checkout, the shopper reviews the items, the total and the card, then approves with a biometric check, which creates a record of the authorization.
  • Card rewards and dispute protections still apply.
  • OpenAI plans spending limits and rules by category or time period, so shoppers could pre-approve some purchases later.

OpenAI has not announced dates for other countries. For stores outside the US, this is a heads-up rather than a change today: US shoppers using Wallet can already buy from sites anywhere, and the settings below are the same everywhere.

How does a ChatGPT Wallet purchase reach my checkout?

Through your normal website. When a dot buys something, it uses ChatGPT's cloud browser, a browser running on OpenAI's computers, to open your product page, add to cart and fill in your checkout form. OpenAI's "Accept payments" page says the shopper approves the purchase in ChatGPT and "your checkout processes the payment." You handle the order, fulfillment, customer support and fraud decisions as usual.

Three details from that page are worth knowing before the first order arrives:

  • You get a network token, not the card number. OpenAI says to use the Payment Account Reference (PAR) to link the token to the underlying card account.
  • The consent covers one purchase. OpenAI says not to save or reuse that credential for a separate purchase. Subscriptions are allowed if your checkout already supports recurring billing and you collect consent for it.
  • You don't need a product feed or a plugin. OpenAI says verified ChatGPT users can use the cloud browser on any site; feeds and plugins are separate, optional extras.

Is my bot protection blocking ChatGPT Wallet purchases?

It may be. The cloud browser is automated traffic from data center addresses, which is exactly what bot management is built to stop. OpenAI's docs list how each major provider labels it:

  • Cloudflare: shown as dots, OpenAI under Personal Agents. OpenAI's steps: in the dashboard, select your domain, go to Security > Settings, filter by Bot traffic, open AI Crawler and Agent access policies, and set dots, OpenAI to Allow (do not block). A WAF custom rule on detection ID 129220581 (bot tag chatgpt-agent) works too.
  • Akamai: the existing ChatGPT Agent bot, in the AI Fetchers and Agents category; OpenAI's steps create a custom bot category and set it to Allow.
  • HUMAN: ChatGPT Agent under Known Bots and Crawlers.
  • Vercel: recognized as ChatGPT Agent (chatgpt-operator); no change needed unless your own rules block it.

All four verify the agent's signature for you, so allowing the named agent does not open the door to anyone who copies its name. OpenAI also says the exception doesn't change how you treat its crawlers, such as OAI-SearchBot, which you control separately in robots.txt (our ChatGPT citations guide covers those).

Shopify, WooCommerce and other platforms aren't in OpenAI's list. If your store sits behind one of the four providers above, check there; if not, ask your platform how it treats signed agent traffic.

Will my fraud rules decline agent orders?

They might, and OpenAI says so directly: risk systems that rely on IP addresses and browser details can flag the cloud browser. OpenAI is rolling out a Forwarded HTTP header that carries signals about the real shopper, such as the country estimated from their IP address (ip-country), a masked network prefix (ip-prefix), their network's AS number (asn), locale, time zone and user agent.

What to do: if a third-party fraud tool screens your orders, ask whether it reads these Forwarded signals. If you run your own rules, start logging the header now. OpenAI notes the signals "may vary" while support rolls out, so don't build a hard rule on any one field yet.

Our test: checking ChatGPT's signature ourselves

ChatGPT signs its cloud browser requests with Web Bot Auth, which uses the HTTP Message Signatures standard, RFC 9421. Each signed request carries Signature, Signature-Input and a Signature-Agent header set to "https://chatgpt.com". The public keys are published at chatgpt.com/.well-known/http-message-signatures-directory.

If your firewall isn't one of the four that verify automatically, OpenAI's advice is to verify the signature yourself before you allow the traffic. A user agent string proves nothing; anyone can send one. We wanted to know how hard verification is, so we wrote it.

On Nov. 15, 2026 the key directory held one Ed25519 key (key ID ArwjqcCqtA5oxEWkzXGC-To_0A9whHmajCHtfe8I9aY, valid from Jan. 1, 2025). Its expiry date moves with each fetch, always seven days out, so treat the directory as something to refresh, not to copy once. Usefully, ChatGPT signs the directory's own response with the same key, which gives anyone a real signature to test against. This script, with Node 18 or later and no packages, checks it:

// verify-chatgpt-signature.mjs: check a Web Bot Auth signature (RFC 9421, Ed25519)
// against the keys ChatGPT publishes. Node 18 or later, no packages.
import crypto from 'node:crypto';
 
const DIRECTORY = 'https://chatgpt.com/.well-known/http-message-signatures-directory';
 
// Web Bot Auth names each key by its JWK thumbprint (RFC 7638)
const thumbprint = (jwk) =>
  crypto.createHash('sha256')
    .update(JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x }))
    .digest('base64url');
 
export async function loadKeys() {
  const body = await (await fetch(DIRECTORY)).json();
  return new Map(body.keys.map((k) => [thumbprint(k), k]));
}
 
// values: each covered component, e.g. { '@authority': 'shop.example', ... }
export function verify({ signatureInput, signature, values, keys, now = Date.now() / 1000 }) {
  const params = signatureInput.replace(/^sig\d+=/, '');
  const covered = params.match(/^\(([^)]*)\)/)[1].trim().split(/\s+/);
  const base = [
    ...covered.map((item) => `${item}: ${values[item.match(/^"([^"]+)"/)[1]]}`),
    `"@signature-params": ${params}`,
  ].join('\n');
 
  const keyid = params.match(/keyid="([^"]+)"/)[1];
  const created = Number(params.match(/created=(\d+)/)[1]);
  const expires = Number(params.match(/expires=(\d+)/)?.[1] ?? Infinity);
  const jwk = keys.get(keyid);
  if (!jwk) return { ok: false, reason: 'unknown key' };
  if (now < created - 60 || now > expires) return { ok: false, reason: 'outside time window' };
 
  const key = crypto.createPublicKey({ key: jwk, format: 'jwk' });
  const sig = Buffer.from(signature.match(/:([^:]+):/)[1], 'base64');
  const ok = crypto.verify(null, Buffer.from(base), key, sig);
  return { ok, reason: ok ? 'valid signature' : 'bad signature' };
}
 
// Self-test: ChatGPT signs its own key directory with the same key
const keys = await loadKeys();
const res = await fetch(DIRECTORY);
const body = Buffer.from(await res.arrayBuffer());
const digest = `sha-256=:${crypto.createHash('sha256').update(body).digest('base64')}:`;
const check = (authority) => verify({
  signatureInput: res.headers.get('signature-input'),
  signature: res.headers.get('signature'),
  values: { '@authority': authority, 'content-digest': res.headers.get('content-digest') },
  keys,
});
console.log('keys:', [...keys.keys()]);
console.log('digest matches body:', digest === res.headers.get('content-digest'));
console.log('real response:', check('chatgpt.com'));
console.log('tampered authority:', check('example.com'));

Our run printed:

keys: [ 'ArwjqcCqtA5oxEWkzXGC-To_0A9whHmajCHtfe8I9aY' ]
digest matches body: true
real response: { ok: true, reason: 'valid signature' }
tampered authority: { ok: false, reason: 'bad signature' }

The real response verified, and changing one signed value broke it, which is the point. The directory signature was valid for 24 hours (its created and expires values are 86,400 seconds apart).

To use verify() on your own traffic, pass every component named in the request's Signature-Input (for example @authority is your own host name) and check that Signature-Agent is exactly "https://chatgpt.com", quotation marks included. Two limits: this parser handles the simple parameter lists we saw, not every form RFC 9421 allows, and it doesn't stop replays. For production, use your CDN's built-in verification where you can. We could not capture a real cloud browser request from here, so we tested on the directory's signature, which uses the same key and format.

Our view: what to do this week

  • If you sell online, open your bot settings today. Find the ChatGPT agent entry and decide on purpose. Blocking it by default means a shopper who asked ChatGPT to buy from you gets a failed checkout and buys elsewhere.
  • Allow the verified agent, not a user agent string. Use your provider's verified entry, or verify signatures as above before any allow rule.
  • Tell your fraud tool about the Forwarded header, and watch declined orders for a few weeks for a pattern.
  • Check that your checkout works without a human. Pop-ups that hide the pay button, address forms that need a click on a suggestion, and CAPTCHAs on every order trip up agents as well as some people.

If you don't sell anything, nothing changes today. The same cloud browser also fills in forms and books things for people, so the bot check is still worth five minutes; our post on Cloudflare's agent settings covers the wider picture, and ChatGPT Business Hub is where to see how often ChatGPT mentions your business.

What we don't know yet

  • When Wallet leaves the US. OpenAI hasn't said, and the first rollout is limited even within the US.
  • How many purchases it brings. OpenAI has published no numbers, and agent orders on other platforms have been small so far, according to TechCrunch's report.
  • How agent orders will show in analytics. The cloud browser runs on OpenAI's computers, so expect these sessions to look unlike normal shoppers in GA4. We will test it when we can.
  • Whether merchants will get controls. OpenAI's FAQ says it doesn't yet offer site owners a way to require a person to confirm checkout, though it requires human review "before any consequential action" for all users.

Sources

Photo of Kiran Dasgupta

About the author

Kiran Dasgupta, Editor

Kiran runs Kihan Marketing, a web design, SEO and ads agency, and manages dozens of websites across real estate, home services and healthcare. He writes about SEO, AI search and paid ads news, and what it means for the people who run websites.