# A deep dive into ChatGPT Wallet

> ChatGPT Wallet lets your dot pay with a one-time token, not your card number. How to add a card, approve purchases, stay safe, and get your website ready.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-11-16 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/chatgpt-wallet/

ChatGPT Wallet is how a ChatGPT agent pays for things. You save a credit card once. Your dot finds what you asked for and fills in the store's checkout, and you approve that exact purchase with Face ID or a fingerprint before any money moves.

OpenAI [announced it](https://openai.com/index/introducing-chatgpt-wallet/) on November 13, 2026, built together with American Express, Mastercard and Visa. It's rolling out to ChatGPT Pro subscribers in the United States, and it works inside conversations with a [dot](https://flaviocopes.com/openai-dots/), the always-on agent OpenAI launched in September.

I live in Italy, so I can't add a card yet, and the buyer's half of this guide follows OpenAI's [help article](https://help.openai.com/en/articles/20001654-making-purchases-with-chatgpt-wallet), the [Wallet terms](https://openai.com/policies/chatgpt-wallet-terms/) and the [privacy notice](https://openai.com/policies/chatgpt-wallet-privacy-notice/). The seller's half runs on open standards, so I could test it: I verified ChatGPT's request signatures with a short Node script, and I looked at what my own site needs to let a dot buy from it.

## What ChatGPT Wallet is

Before Wallet, an agent that wanted to buy something for you had two bad options. It could stop at the checkout and hand the page back to you, or it could type your real card number into a form, which means the model has seen your card.

Wallet adds a third one. Your card lives in a vault the model can't read. When you approve a purchase, the card network creates a **payment token**, a substitute card number with its own security code and expiration date, and the dot types that into the store's checkout. The charge lands on your real card, but the store and the agent never see its number.

A few things Wallet is not:

- It's not a balance. You don't top it up, and OpenAI doesn't hold your money.
- It's not a bank account or a line of credit. The terms say OpenAI "is not a bank, card issuer, payment network, lender, or merchant".
- It's not crypto. It uses the card you already have, on the card networks stores already accept.
- It's not the card that pays for your ChatGPT subscription. Wallet cards are stored separately from that one, and from your ChatGPT gift card or prepaid balance.

It also works in one place only, a conversation with your dot. A normal chat, ChatGPT Work and a standalone Codex thread can't use it.

## Who can use it

The rollout is narrow, and even an eligible account may not have Wallet on day one.

| Requirement | Detail |
| --- | --- |
| Plan | ChatGPT Pro, which starts at $100 a month |
| Country | You live in the United States and use Wallet there |
| Age | 18 or older |
| Agent | A dot, already set up |
| Card | A US-issued American Express, Chase, Mastercard or Visa credit card, with a US billing address |
| Chase cards | You must be the primary cardholder, not an authorized user |
| Device | One that can do a biometric check, like Face ID or Touch ID |
| Business cards | Allowed if your company permits storing the card for purchases |

Debit cards don't work. Virtual cards don't work at launch either, which is a little confusing because Wallet itself pays with a virtual number. That one is created by the network for a single purchase, and you can't add your own.

OpenAI hasn't given a date for other plans or other countries. On the Pro plan, dots themselves aren't available in the European Economic Area, the UK or Switzerland, so for many of us there are two rollouts to wait for. I wrote about that wait in [the AI product I can use](https://flaviocopes.com/ai-product-availability/).

Neither the Wallet terms nor the merchant documentation mentions a fee from OpenAI. Your card's own interest, fees and rewards keep working as they do for any other purchase.

## How a purchase works

Here's the whole trip, from your request to the charge:

```mermaid
flowchart TD
  accTitle: A purchase with ChatGPT Wallet
  accDescr: You ask your dot to buy something. The dot prepares the order on the store's website and Wallet shows you a purchase request. If you decline, nothing is charged. If you approve with a biometric check, the card network issues a payment token, the dot enters it at checkout, and the store charges your card through the network.
  A[You ask your dot to buy something] --> B[Dot fills the cart and the checkout form]
  B --> C[Wallet shows a purchase request]
  C --> D{You review it}
  D -->|Decline| E[Nothing is charged]
  D -->|Approve with Face ID| F[Card network issues a payment token]
  F --> G[Dot enters the token at checkout]
  G --> H[Store charges the token]
  H --> I[The charge lands on your card]
```

The dot does the shopping with its own browser, on the store's normal website. The store doesn't need an OpenAI integration, and the token looks like a card to its payment form.

Your approval sits in the middle. You give it on the purchase request, with a biometric check, and each approval creates a record of what you authorized.

An approved purchase can still fail. Your card issuer decides whether to authorize the charge, and the store decides whether to accept the order. The store's fraud checks may also find an order placed from a cloud browser suspicious, which I cover in the section for site owners.

## The payment token

The token is the reason this is safer than giving an agent your card.

The technical name is a **network token**. Visa, Mastercard and American Express have issued them for years, and Apple Pay and Google Pay work on the same idea. The network keeps the link between the token and your real account, so only the network and your bank can turn one into the other.

The help article says Wallet generates a token "for each use". The merchant documentation says the store may not save it for a separate purchase, because you consented to one specific transaction. So a token that leaks from a page or a log can't be used the way a stolen card number can.

You'll notice it in one place. The card number on the store's receipt, or the last four digits in the order email, can differ from the ones on your physical card.

The privacy notice spells out who receives what:

| Who | What they get |
| --- | --- |
| The secure card form, run by OpenAI's payment provider | Your full card number, expiration date, security code and billing address |
| OpenAI | A tokenized credential, the network, issuer, card type, last four digits, expiration date, and billing country or postal code. Not the full number, not the security code |
| Your dot | The order it prepared and the token to pay for it. No real card details |
| The store | The token, plus the name, contact and delivery details the order needs |
| Your issuer and the card network | The transaction, like any card payment |
| Your phone or laptop | Your face or fingerprint. OpenAI gets the result of the check, not the scan |

OpenAI also keeps a record of every purchase request, whether you approved or rejected it, the device you used, and what was sent to the store. It says it doesn't sell Wallet data or use it for targeted advertising.

## Add a card

You need a dot before you can use Wallet. If you don't have one, my [deep dive into dots](https://flaviocopes.com/openai-dots/) walks through creating it.

There are two ways to start. The first is to ask your dot:

```text
Help me add a card to Wallet.
```

It replies with a secure card-setup request or a link. Open it.

The second is from the app. On mobile, open **Settings** from the left navigation, select **Wallet**, then **Add Card**.

Both lead to the same secure form:

1. Enter the card number, expiration date and security code. For American Express, that's the 4-digit code on the front.
2. Review the Wallet terms and the privacy notice, then select **Add card**.
3. Complete your bank's verification if it asks for one.
4. Wait for **Card added** before you try to buy anything.

A third way exists too. If you start a purchase with no card saved, the dot shows you the same setup flow at checkout.

Be careful with one thing. Type card details and bank codes only in that form, never in the conversation. The form goes to the payment provider's vault. A chat message goes to the model.

### Bank verification

Your bank may want to confirm it's you. That can be a code it sends you, or an approval in its app. The bank picks the method, not OpenAI.

It may also place a temporary authorization on the card. The terms say it's a verification, not a purchase, and it gets reversed.

Chase has its own flow. Install the Chase app and sign in with biometrics before you start. During setup you follow a link to approve the connection in the Chase app, or scan a QR code with your phone if you're on a computer, and then you return to Wallet to finish.

If the bank locks your card during verification, stop and call the bank. OpenAI can't unlock it.

Not sure whether the card was saved? Ask your dot to show your saved cards before adding it a second time.

## Buy something with your dot

You shop by describing what you want. OpenAI's own examples are short:

```text
Help me find a new sweater.
```

```text
Book me a hotel for my trip to Chicago next weekend.
```

A dot does better with the constraints you'd otherwise apply in your head. Give it the budget, the size, the delivery deadline and the stores you trust:

```text
Find a navy merino crew-neck sweater, men's medium, under $120
including shipping, delivered before November 27. Only stores with
free returns. Show me your top three before you put anything in a cart.
```

Once you've picked one, ask the dot to complete the purchase. It fills the cart and the checkout, and a **purchase request** appears.

### Read the purchase request

This screen is where you do your part. The terms list what Wallet shows, when it has the information:

- the merchant
- the items or services, and the quantity
- the total, or a maximum price, including known taxes, fees and shipping
- the card that will be charged
- whether the purchase creates a recurring charge, a deposit or an authorization hold

Check the merchant name first. A dot that searched the web may have landed on a reseller you've never heard of. Then check the quantity, and that the total matches what you saw in the conversation.

If everything is right, select **Approve** and pass the biometric check. If anything is off, decline. Declining costs nothing, and you can tell the dot what to fix.

Your approval is narrow. The terms say it's "limited to the merchant, items or services, amount, card, recipient, delivery details, and other terms shown to you". If a material detail changes before the order is submitted, Wallet asks you to approve the updated purchase.

### Approve from another device

Approval needs biometrics, so it has to happen on a device that has them.

If you're on one that doesn't, Wallet shows a link or a QR code. Open it on a supported device signed in to the same ChatGPT account, and approve there. On a laptop with the lid closed, open the lid to use Touch ID, or continue on your phone.

### "Ready to check out" is not "order placed"

After you approve, the dot goes back to the store's checkout, enters the token, and reports what happened.

The status **Ready to check out** means your approval went through. It doesn't mean the store accepted the order. Wait for the dot's report, and look for the store's confirmation email.

This matters most when something breaks. If the conversation errors out, checkout expires, or the dot stops responding, don't ask it to try again right away. Check your inbox and the store's order status first, or you might end up with two sweaters.

A failed checkout can leave a pending charge on your card. That's a hold. Ask the store whether an order exists, and ask your issuer when the hold will clear.

### The store may need more than a card

A checkout usually wants a name, an email, a phone number and a delivery address. Your dot can ask you for those in the conversation, and that's fine, because they aren't secrets in the way a card number is.

It should never ask for a card number, a security code or a bank verification code in chat. If it does, something is wrong. Don't answer.

## Subscriptions and recurring charges

A subscription is the one case where the store keeps a payment credential.

If you approve a purchase with a recurring plan, the merchant may store the credential and charge it again, under the plan's terms. Wallet shows the recurring terms on the purchase request, so read that line twice.

From then on, the subscription is between you and the store. You cancel it with the store, and removing the card from Wallet doesn't stop the charges.

## Manage your cards

You manage cards by talking to your dot. Ask it to show your saved cards, and you get each card's nickname, last four digits and expiration date.

To change the default:

```text
Make the card ending in 1234 my default.
```

To remove one, ask for it by its last four digits. Check that the confirmation names the right card before you confirm. Then ask for the list again to see that it's gone.

Removing a card stops new Wallet payments with it. It doesn't cancel an order, close the card with your bank, stop a subscription, or delete your Wallet history. The privacy notice says a removed card stays for a limited time, to deactivate the credential and complete pending transactions.

One more detail: a card saved in Wallet is not the same as a card saved on a store's website. If you have an account with the store and a card on file there, the dot could pay with either. The purchase request shows which.

## When something goes wrong

There are three parties to call, and picking the right one saves days.

| Problem | Who to contact |
| --- | --- |
| Where's my order, cancel it, return it, refund it | The store |
| Stop a subscription | The store |
| A charge I don't recognize | Your card issuer, promptly |
| A declined or pending charge | Your card issuer |
| The bank's verification failed or locked my card | Your card issuer |
| Wallet shows an error, or I can't add or remove a card | OpenAI Support |
| The purchase differs from what I approved | OpenAI Support |
| Someone got into my ChatGPT account | OpenAI Support, then your issuer |

The reason is in the terms. The store is the seller and the merchant of record, so returns and refunds follow its policy. OpenAI "does not decide or fund merchant refunds or card chargebacks".

Then there's a paragraph in capitals. OpenAI "does not assume any liability" for purchases, payments, order fulfilment or other activity made with Wallet, and you agree to look to your issuer, the network or the merchant to resolve disputes.

What you keep are the rights your card already gives you, and your rewards. It helps that Wallet takes credit cards only. In the US, a credit card comes with stronger dispute and fraud protections than a debit card, and a disputed charge isn't money missing from your checking account while you argue about it.

OpenAI says it may provide Wallet records to help. The record of what you approved is your best evidence when an order doesn't match.

When you write to OpenAI Support about a checkout problem, include the merchant, the amount, the currency, any order reference, the exact error and the step that failed. Never send a full card number, a security code or a verification code.

## How safe it is

The parts I trust:

- The model never has your card. A prompt injection that makes a dot leak everything it knows can't leak a number it was never given.
- Every purchase needs a biometric check on your device. A web page can trick your dot into putting the wrong thing in the cart. It can't pass Face ID for you.
- The approval covers one order at one total, and a material change needs a new one.
- The token is made for one purchase.
- Disputes go through a credit card, with its existing protections.

The parts that are still on you:

- The dot can pick the wrong item, the wrong size or the wrong seller. The terms say it plainly: "AI systems can make mistakes."
- The approval screen only helps if you read it. Approving on reflex gives all of this away.
- A scam store is still a scam store. If you don't recognize the seller, decline.
- Your ChatGPT account is now worth more to an attacker. Protect it with a [passkey](https://flaviocopes.com/passkeys-webauthn/), and turn on charge notifications in your bank's app so you see every purchase the moment it happens.

This is the rule I use for any agent that can do something I can't undo: it prepares, and a person approves the exact action. I explained it in [how to let an AI agent perform irreversible actions safely](https://flaviocopes.com/ai-agent-irreversible-actions-safely/). Wallet is built the same way, and that's the main reason I'd be comfortable with it.

## Purchases without asking are coming

Today every purchase needs your approval. OpenAI says that will change. It expects you'll be able to delegate purchases entirely to your agent by setting spending limits, purchase categories or time periods, and pre-approve everything that fits inside them.

The terms are already written for it. They say you must approve each purchase "or grant ChatGPT the authority to approve each purchase in advance", and that OpenAI may set transaction, merchant and category limits.

There's no date. When it arrives, I'd leave it off for my own money, at least until it's clear who pays when the agent buys the wrong thing inside the limits you set. I went through that reasoning in [what happens when AI agents shop for us](https://flaviocopes.com/agent-checkout/).

## ChatGPT Wallet and the other ways agents pay

Wallet isn't the first attempt at this, and the differences are in who has to do the work.

| | How the agent pays | Who approves | Where it works |
| --- | --- | --- | --- |
| ChatGPT Wallet | A one-time network token on your own credit card | You, each purchase, with biometrics | Any site the dot's browser can use |
| Instant Checkout (ChatGPT, 2025) | A checkout inside ChatGPT, built with Stripe | You, in the chat | Only merchants that integrated it |
| Link in Meta's Muse | A one-time card from Stripe's wallet | You approve the total in the chat | Stores Muse can check out on |
| x402 with stablecoins | USDC, sent inside a web request | Nobody per payment, within limits set in advance | APIs and services that accept it |

Instant Checkout asked every store to build an integration. Wallet asks the store for nothing, because a browser and a card number already work everywhere, and that's the bet OpenAI is making this time.

The stablecoin tools from Coinbase and Circle solve a different problem. They let software pay other software fractions of a cent with no person involved. Wallet is for a person buying a sweater, with the card protections that person already has.

## For site owners: accepting Wallet payments

If you sell something online, the first thing to know is that there's nothing to integrate. OpenAI's [Accept payments guide](https://developers.openai.com/commerce/guides/accept-payments) says Wallet "works out of the box with existing checkout pages and payment forms".

A dot visits your site with a browser that runs on OpenAI's cloud, and pays with a token your payment form treats as a card. You stay the seller. The order, the fulfillment, the support and the fraud decision are yours, as if the customer had clicked the buttons themselves.

What can go wrong is that your own defenses stop the sale. There are two places:

```mermaid
flowchart TD
  accTitle: Where a Wallet purchase can be blocked on your site
  accDescr: A dot's cloud browser sends signed requests. The CDN or firewall can block them as bot traffic or verify the signature and let them through. The checkout then submits a network token, and the payment processor's risk checks can decline it, or pass it to the card issuer, who authorizes the charge.
  A[Cloud browser sends a signed request] --> B{CDN or firewall}
  B -->|Treated as a bot| C[Blocked before it sees your page]
  B -->|Signature verified| D[Your site and checkout]
  D --> E[Checkout submits the network token]
  E --> F{Payment processor and risk checks}
  F -->|Looks like fraud| G[Declined or canceled]
  F -->|Passes the checks| H[Issuer authorizes the charge]
```

The first is your CDN or firewall, which may treat a cloud browser as a bot. The second is your payment risk system, which may decline an order because the IP address and the browser don't look like a customer's.

### Let the cloud browser in

The cloud browser is not a crawler. `GPTBot` collects training data and `OAI-SearchBot` builds the search index, and you control both in [robots.txt](https://flaviocopes.com/robots-txt-ai-crawlers/). The cloud browser acts for one user who asked for something, and it identifies itself with a cryptographic signature on each request.

OpenAI's [Agent Access page](https://developers.openai.com/commerce/agent-access) says you don't need to add it to an allowlist. You only need to act if your security settings block it. Akamai, Cloudflare, HUMAN and Vercel verify the signature for you.

My site is on Cloudflare, so these are the steps that apply to me:

1. In the Cloudflare dashboard, select the domain and go to **Security > Settings**.
2. Filter by **Bot traffic** and open **AI Crawler and Agent access policies**.
3. Under **Personal Agents**, set **dots, OpenAI** to **Allow**.
4. Save.

If you manage bots with WAF custom rules, create a rule on **Bot Detection ID equals** `129220581` (the bot tag is `chatgpt-agent`, listed as ChatGPT Operator), and set it to allow or skip.

On Akamai and HUMAN the entry is called **ChatGPT Agent**. On Vercel it's `chatgpt-operator`, and there's nothing to configure unless your own rules block it.

An exception like this applies to the whole site. Keep your page-level access controls as they are, and note that OpenAI has no feature for a site to require human confirmation on its own pages. The human review happens on the user's side, before any consequential action.

### Verify the signature yourself

If your CDN isn't one of those four, you can check the requests in your own code. ChatGPT uses **Web Bot Auth**, which is built on HTTP Message Signatures, [RFC 9421](https://www.rfc-editor.org/rfc/rfc9421).

A signed request carries three headers:

- `Signature`, the signature itself
- `Signature-Input`, which says what was signed, when, and with which key
- `Signature-Agent`, set to `"https://chatgpt.com"`, quotes included

The public keys are in a directory anyone can fetch:

```bash
curl -s https://chatgpt.com/.well-known/http-message-signatures-directory | jq
```

```json
{
  "keys": [
    {
      "crv": "Ed25519",
      "kty": "OKP",
      "x": "P_1c4SX6fCavDcq6FRegWcVvaOKsp_aXHPEN1FcKDIA",
      "kid": "ArwjqcCqtA5oxEWkzXGC-To_0A9whHmajCHtfe8I9aY",
      "use": "sig",
      "nbf": 1735689600,
      "exp": 1795453449
    }
  ],
  "signature_agent": "https://chatgpt.com",
  "purpose": "ai"
}
```

It's one Ed25519 key in JWK format, and Node can verify Ed25519 with no dependencies.

To verify, you rebuild the exact text that was signed, called the **signature base**: one line per signed component, in the order `Signature-Input` lists them, then a last line with the signature parameters. Then you check the signature against that text with the public key.

I can't make a dot visit my server from Italy, but the directory response is itself signed with the same key, so it makes a real test. This script verifies it, then changes one signed header and verifies again:

```js
import { createPublicKey, verify } from 'node:crypto'

const directory = 'https://chatgpt.com/.well-known/http-message-signatures-directory'

const verifySignature = async ({ authority, headers }) => {
  const input = headers.get('signature-input')
  const params = input.slice(input.indexOf('=') + 1)
  const components = params.slice(1, params.indexOf(')')).split(' ')

  const expires = Number(params.match(/expires=(\d+)/)[1])
  if (expires < Date.now() / 1000) return false

  const base = components
    .map((component) => {
      const name = component.split(';')[0].replaceAll('"', '')
      const value = name === '@authority' ? authority : headers.get(name)
      return `${component}: ${value}`
    })
    .concat(`"@signature-params": ${params}`)
    .join('\n')

  const { keys } = await (await fetch(directory)).json()
  const keyid = params.match(/keyid="([^"]+)"/)[1]
  const jwk = keys.find((key) => key.kid === keyid)
  if (!jwk) return false

  const key = createPublicKey({ key: jwk, format: 'jwk' })
  const signature = Buffer.from(headers.get('signature').match(/:(.+):/)[1], 'base64')
  return verify(null, Buffer.from(base), key, signature)
}

const response = await fetch(directory)
const headers = new Headers(response.headers)
console.log('signed by', headers.get('signature-input').match(/keyid="([^"]+)"/)[1])
console.log('valid    ', await verifySignature({ authority: 'chatgpt.com', headers }))

headers.set('content-digest', 'sha-256=:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=:')
console.log('tampered ', await verifySignature({ authority: 'chatgpt.com', headers }))
```

Save it as `verify.mjs` and run it with `node verify.mjs`:

![A terminal showing the ChatGPT key directory fetched with curl, then node verify.mjs printing the key id, valid true and tampered false](https://flaviocopes.com/images/chatgpt-wallet/verify.webp)

The real signature passes, and the same signature over a changed header fails.

For a request arriving at your server, call the same function with `authority` set to your own hostname and the request's headers. Before you trust the result, add two checks. `Signature-Agent` must be exactly `"https://chatgpt.com"`, and the key directory should come from a cache, not from a fetch on every request.

Only allowlist a request after its signature verifies. The `Signature-Agent` header alone proves nothing, because anyone can send it.

### Read the Forwarded header

A firewall that lets the dot in doesn't help if the payment gets declined afterwards.

Risk systems look at the IP address, the browser and the location of whoever is paying. With a dot, they see OpenAI's data center, which matches nothing about your customer.

To fix that, OpenAI is rolling out support for relaying signals about the real user in the standard `Forwarded` HTTP header:

| Parameter | What it is | Example |
| --- | --- | --- |
| `for` | IP address observed for the ChatGPT user | `198.51.100.23` |
| `ip-prefix` | Masked network prefix of that address | `"192.0.2.0/24"` |
| `ip-country` | Two-letter country estimated from the address | `US` |
| `asn` | Autonomous system number of the user's network | `64496` |
| `locale` | The user's configured locale | `en-US` |
| `tz` | The user's time zone | `"America/Los_Angeles"` |
| `user-agent` | The user's browser or app | `"ExampleApp (iOS)"` |

A header for a fraud check looks like this:

```http
Forwarded: asn=64496;ip-prefix="192.0.2.0/24";user-agent="Example/130"
```

Parsing it takes one regular expression, because values can be quoted and a quoted value can contain a semicolon:

```js
const parseForwarded = (header) =>
  Object.fromEntries(
    [...header.matchAll(/([\w-]+)=("[^"]*"|[^;,]*)/g)].map(([, name, value]) => [
      name.toLowerCase(),
      value.replace(/^"|"$/g, ''),
    ])
  )

console.log(parseForwarded('asn=64496;ip-prefix="192.0.2.0/24";user-agent="Example/130"'))
```

```js
{
  asn: '64496',
  'ip-prefix': '192.0.2.0/24',
  'user-agent': 'Example/130'
}
```

The set of parameters you receive can vary while OpenAI rolls this out, so treat every one as optional. And only read these values on a request whose signature you verified, or you're trusting a header anyone can forge.

If a provider handles risk for you, ask them whether they read these signals. OpenAI says it's working with Forter, Riskified, Sardine and Signifyd on the fraud side, and with Adyen, Checkout.com and Stripe on the payment side, so their systems recognize agent purchases.

### What your checkout receives

Your payment form gets a network token where the card number would be. A few rules come with it:

- You never receive the real card number. To recognize the same customer account across tokens, use the Payment Account Reference (PAR) your processor returns.
- The customer approved one transaction. Don't save the credential and reuse it for a different purchase.
- Subscriptions work if your checkout supports recurring billing. Get the customer's consent for the recurring charge, and follow your processor's rules for merchant-initiated transactions.
- A card the customer already saved in their account with you keeps working. Wallet is one more payment option next to it.

Support doesn't change. OpenAI's FAQ says payment or order errors "should be handled in the same way you would if a customer took the action themselves".

### Going further: feeds, plugins and sign-in

Browser access is the floor. The [Commerce Partner Playbook](https://developers.openai.com/commerce/guides/overview) lists what you can add on top, in rough order of effort.

Start by claiming your business in Business Hub, the dashboard OpenAI opened on November 10, 2026. Once verified, you can correct your details and see how often ChatGPT mentions you.

If you sell physical products, upload a product feed with current prices and availability. The feed helps a dot find your product. It isn't required for a dot to buy it.

A **plugin** is the bigger step. It's an MCP server plus skills that let ChatGPT call your backend directly: look up a product, build a cart, prepare a checkout. One tool call can replace several page loads, and it doesn't break when you move a button. The docs ask for a headless plugin (iframe-based UI isn't supported in dots), with product lookup and carts that work without a login, and a `continue_url` that hands the customer to your website when the plugin can't finish a step.

If your checkout needs an account, there's **Sign in with ChatGPT**. It's limited to selected commerce partners for now, and you have to ask OpenAI to be allowlisted.

Websites can also describe their actions to agents with WebMCP, which I covered in [how to add WebMCP tools to your website](https://flaviocopes.com/webmcp/).

## How I would use it

As a buyer, I can't until Wallet leaves the US.

When it does, I would use it for purchases where I already know the exact product, and the work is finding a seller with stock and decent shipping. I'd pair it with a credit card that sends a notification for every charge. I wouldn't use it for anything where the choice is the hard part, like a laptop or a flight with a connection, because there the approval screen tells me the price and not whether the pick was right.

As a seller, my situation is common for small software businesses. I sell my Mac apps through Polar, which is the [merchant of record](https://flaviocopes.com/merchant-of-record/). The checkout page is on Polar's domain, so the firewall in front of it and the risk checks behind it are Polar's, and I can't tune them.

What I control is this site, where the app pages say what each app does and what it costs. It's on Cloudflare, and its `robots.txt` already welcomes OpenAI's crawlers by name:

```text
User-agent: GPTBot
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /
```

That covers being found and read. For a dot's browser, the setting that counts is the **dots, OpenAI** entry in Cloudflare's agent policies, and that's the one I'd check on any site of mine that sells something.

Wallet is a poor fit in a few cases. It does nothing for buyers outside the US or without a Pro plan, which today is almost everyone. It won't complete a checkout that wants a debit card, a bank transfer or a local payment method. And if your store's bot protection is strict and you can't change it, a dot's order may be declined or canceled no matter what the buyer approved.

If you sell online, the useful thing to do this week is small. Open your CDN's bot settings, find the entry for ChatGPT's agent, and check that it isn't blocked.
