
Posted on ยท 7 min read
ChatGPT Wallet Lets AI Agents Buy Things. Your Checkout's IP Check Will Think It's Fraud
On this page ยท 11 sections
On November 13, 2026, OpenAI launched ChatGPT Wallet. It lets ChatGPT's agents pay for things on your behalf, starting with Pro subscribers in the US. The agent never sees the card number, and every purchase goes through a security check.
If you run a checkout, the interesting part is where those orders come from. The agent shops in a cloud browser that OpenAI hosts. So the request that places the order doesn't come from the buyer's home connection. It comes from a data centre.
Most fraud checks treat a data centre address as a warning sign. OpenAI says so itself in its guide to accepting payments:
Risk systems are often tuned to detect bots and rely on observed signals like IP addresses or details about the connected browser. ChatGPT's cloud browser can set off these systems by accident and cause purchases to fail.
We wanted to see that failure for ourselves. So we ran OpenAI's published addresses through the ipstack API, then wrote a small JavaScript check that still works when the buyer is an agent. Everything below ran on November 16, 2026.
#What is the ipstack API?
ipstack takes an IP address and returns where it is and who runs it: country, region, city, time zone, ASN and ISP. Add security=1 and you also get a security object with proxy, Tor, crawler and hosting flags, plus a threat level.
The security module isn't on every plan. We have two keys, and only one of them returns it. The free plan gives you 100 lookups a month, which is enough to follow along with the location fields.
Outside of fraud checks, the same lookup can pick a default currency, pre-fill a country on a form or route a visitor to the nearest region.
#How to Look Up an Address With the Security Module
One request:
curl "https://api.ipstack.com/104.208.184.193?access_key=YOUR_KEY&security=1"That address is the first one in chatgpt-user.json, the list of ranges OpenAI publishes for requests ChatGPT makes on a user's behalf. Here's what came back, with the region, coordinates and empty fields cut:
{
"ip": "104.208.184.193",
"country_code": "US",
"city": "Boydton",
"connection": {
"asn": 8075,
"isp": "Microsoft Corporation",
"home": false
},
"security": {
"is_proxy": false,
"is_crawler": false,
"crawler_name": null,
"is_tor": false,
"threat_level": "low",
"hosting_facility": true
}
}Boydton, Virginia is an Azure data centre town. hosting_facility is true and the network is Microsoft's AS8075. A rule that says "hold orders from hosting providers" holds this one.
One caveat before the numbers. OpenAI's commerce docs don't list the cloud browser's addresses, and they say you don't need an allowlist for it. The chatgpt-user.json file is the closest published list of OpenAI egress addresses, so that's what we tested. Your logs will show you the real ones.
#What 12 OpenAI Addresses Looked Like to a Fraud Check
The file had 237 IPv4 ranges when we fetched it. We took the first address of every 20th range, which gave us 12 lookups.
All 12 belonged to Microsoft's AS8075. After that, they stopped agreeing:
- 7 had
hosting_facility: true. - 2 had
hosting_facility: falsebut were labelled as a crawler, withcrawler_name: "ChatGPT-User/1.0"andcrawler_type: "ai_crawler". - 3 had neither flag. To the security object they looked like any other address.
So a check that reads one flag misses some of them. Ours treats either flag as "data centre" and passes the ASN through as well, because the ASN was the only field that was the same on all 12.
One address (68.154.28.97) came back with connection.home: true and hosting_facility: true at once. We'd take the hosting flag over the home flag there.
#Why the Country Check Fails Too
Wallet is US only at launch. Our 12 addresses were in six countries: 7 in the US, and one each in the Netherlands, Brazil, India, Switzerland and Belgium.
A lot of checkouts compare the IP's country with the card's billing country. If the cloud browser leaves from Singapore or Brussels, a US buyer with a US card looks like a cross-border order from a data centre. That's two red flags for a completely normal purchase.
The fix isn't to stop checking. It's to check the buyer, not the browser.
#How ChatGPT Tells You Who the Buyer Is
OpenAI is rolling out two things that help. The first is identity. Cloud browser requests are signed with Web Bot Auth: each one carries Signature, Signature-Input and a Signature-Agent header set to "https://chatgpt.com". The public key lives in a directory you can fetch:
curl https://chatgpt.com/.well-known/http-message-signatures-directory{"keys":[{"crv":"Ed25519","kty":"OKP","x":"P_1c4SX6fCavDcq6FRegWcVvaOKsp_aXHPEN1FcKDIA","kid":"ArwjqcCqtA5oxEWkzXGC-To_0A9whHmajCHtfe8I9aY","use":"sig","nbf":1735689600,"exp":1795441707}],"signature_agent":"https://chatgpt.com","purpose":"ai"}If you're behind Cloudflare, Akamai, HUMAN or Vercel, they can identify the request for you (Cloudflare's bot tag is chatgpt-agent). Otherwise you verify it yourself as an RFC 9421 HTTP message signature.
The second is the buyer's own signals, relayed in the standard Forwarded header. The docs list for (the IP address observed for the ChatGPT user), ip-country, asn, ip-prefix, locale, tz and user-agent. Their examples look like this:
Forwarded: ip-country=CA
Forwarded: locale=en-GB;tz="Europe/London"
Forwarded: asn=64496;ip-prefix="192.0.2.0/24";user-agent="Example/130"The docs also say "the signals you receive may vary as we roll out support for every site". So you can't count on any one of them being there.
#The Check
No dependencies. It needs Node 18 or newer for fetch.
// checkout-signals.mjs: IP risk signals that still work when the buyer is an AI agent (ipstack).
const cache = new Map();
export async function ipInfo(ip) {
if (cache.has(ip)) return cache.get(ip);
const url = new URL(`https://api.ipstack.com/${ip}`);
url.searchParams.set("access_key", process.env.IPSTACK_ACCESS_KEY);
url.searchParams.set("security", "1");
const d = await (await fetch(url)).json();
// ipstack puts failures in the body as {success: false, error: {...}}. A wrong key is also a 401.
if (d.success === false) throw new Error(`ipstack ${d.error.code}: ${d.error.type}`);
const info = {
country: d.country_code, // null for addresses ipstack can't place, never a guess
asn: d.connection?.asn ?? null,
isp: d.connection?.isp ?? null,
// No single flag covered every cloud address we tried, so any one of them counts.
datacenter: Boolean(d.security?.hosting_facility || d.security?.is_crawler),
anonymizer: Boolean(d.security?.is_proxy || d.security?.is_tor),
};
cache.set(ip, info);
return info;
}
// RFC 7239 pairs: ip-country=CA;tz="Europe/London";for="[2001:db8::23]"
export function parseForwarded(header = "") {
const out = {};
for (const part of header.split(/[;,]/)) {
const i = part.indexOf("=");
if (i < 0) continue;
const value = part.slice(i + 1).trim().replace(/^"|"$/g, "").replace(/^\[|\]$/g, "");
out[part.slice(0, i).trim().toLowerCase()] = value;
}
return out;
}
export async function checkoutSignals({ socketIp, forwarded, billingCountry, signedByChatGPT = false }) {
const conn = await ipInfo(socketIp);
// Anyone can type a Forwarded header. Read it only after the Web Bot Auth signature has verified.
const fwd = signedByChatGPT ? parseForwarded(forwarded) : {};
let country = conn.country, source = "socket ip";
if (signedByChatGPT) {
if (fwd["ip-country"]) [country, source] = [fwd["ip-country"].toUpperCase(), "forwarded ip-country"];
else if (fwd.for) [country, source] = [(await ipInfo(fwd.for)).country, "forwarded for (ipstack)"];
else [country, source] = [null, "none: agent sent no user signals"];
}
const reasons = [];
if (!signedByChatGPT && conn.datacenter) reasons.push(`data centre address (${conn.isp})`);
if (!signedByChatGPT && conn.anonymizer) reasons.push("proxy or Tor exit");
if (country === null) reasons.push("buyer country unknown");
else if (country !== billingCountry) reasons.push(`buyer in ${country}, card billed in ${billingCountry}`);
return {
agent: signedByChatGPT,
connection: { country: conn.country, asn: conn.asn, isp: conn.isp, datacenter: conn.datacenter },
buyer_country: country,
buyer_country_source: source,
action: reasons.length ? "review" : "allow",
reasons,
};
}signedByChatGPT is a boolean you pass in. It should be true only when your edge provider or your own RFC 9421 code has verified the signature. We haven't had a signed Wallet request hit a server of ours yet, so we left verification out instead of publishing code we couldn't test.
When the request is signed, the data centre flag stops counting against it. A verified agent is supposed to be in a data centre. The buyer's country comes from ip-country if it's there, and from an ipstack lookup of for if it isn't.
#What the Check Returned
We called checkoutSignals with real addresses and a US billing country each time.
An unsigned request from the Virginia address. This is what a checkout does today:
{"agent":false,"connection":{"country":"US","asn":8075,"isp":"Microsoft Corporation","datacenter":true},"buyer_country":"US","buyer_country_source":"socket ip","action":"review","reasons":["data centre address (Microsoft Corporation)"]}The same thing from a Singapore address in the file (13.76.116.81) gets both flags:
{"agent":false,"connection":{"country":"SG","asn":8075,"isp":"Microsoft Corporation","datacenter":true},"buyer_country":"SG","buyer_country_source":"socket ip","action":"review","reasons":["data centre address (Microsoft Corporation)","buyer in SG, card billed in US"]}Now a signed request from that Singapore address, with Forwarded: ip-country=US:
{"agent":true,"connection":{"country":"SG","asn":8075,"isp":"Microsoft Corporation","datacenter":true},"buyer_country":"US","buyer_country_source":"forwarded ip-country","action":"allow","reasons":[]}A signed request with Forwarded: for=73.0.0.1;asn=7922 (a Comcast address) had no ip-country, so the check looked up the for address. It resolved to the US and the order was allowed, with "buyer_country_source":"forwarded for (ipstack)".
Then the two cases that surprised us.
We tried the docs' own example, for=198.51.100.23. That's a reserved documentation address. ipstack answered HTTP 200 with every field null and the coordinates at 0.0, 0.0. If your code reads country_code and compares it to "US", a null is just "not US" and the order fails for the wrong reason. Ours reports "buyer country unknown" so a person can tell the difference.
And we sent an unsigned request from Singapore with Forwarded: ip-country=US typed in by hand. The check ignored the header and flagged the order on both counts. That one line is the whole security model. A fraudster can type a header, but can't sign as chatgpt.com.
#How to Stay Inside the Request Quota
The cloud browser's addresses repeat, which is why ipInfo keeps a Map. In production, put a TTL on it (an hour is fine for an address's country and network) and share it across instances in Redis or your database.
Do the lookup once, at the point where an order is placed. You don't need it on every page view of a checkout.
When ipstack itself fails, the function throws. Catch that in your order handler and send the order to review. A failed lookup shouldn't approve an order, and it shouldn't decline one either.
#How to Vibe Code the Check
If you ask an AI assistant for "an IP fraud check that supports ChatGPT agents", you'll get one that trusts the Forwarded header from anybody. The signature rule and the null handling have to be in the prompt:
Write checkout-signals.mjs with no dependencies. ipInfo(ip) calls
https://api.ipstack.com/<ip>?access_key=IPSTACK_ACCESS_KEY&security=1, throws when the body has
success:false, caches results in a Map, and returns {country, asn, isp, datacenter, anonymizer}
where datacenter is security.hosting_facility OR security.is_crawler, and anonymizer is
security.is_proxy OR security.is_tor. country stays null when ipstack returns null.
parseForwarded(header) parses RFC 7239 pairs, strips quotes and IPv6 brackets, lowercases keys.
checkoutSignals({socketIp, forwarded, billingCountry, signedByChatGPT}) must IGNORE the Forwarded
header unless signedByChatGPT is true. When signed: buyer country is ip-country, else an ipInfo
lookup of for, else null. Data centre and anonymizer flags only count for unsigned requests.
A null buyer country is "unknown", never a mismatch. Return {agent, connection, buyer_country,
buyer_country_source, action: "allow" | "review", reasons}.Then test it the way we did. Send a Forwarded header without the signed flag and make sure nothing changes. Look up 198.51.100.23 and check that the reason says unknown, not mismatch. And read the line that sets datacenter yourself: if it only checks hosting_facility, it will miss the addresses that came back as crawlers.
#Things to Sort Out Before You Launch
Treat this as one signal among several. allow here means "the IP gives no reason to stop", not "approve the order". Your payment provider's risk score, the order value and the account's history still decide. OpenAI's docs are clear that fraud decisions stay with the merchant.
Talk to your risk vendor. If a third party scores your orders, the Forwarded signals have to reach them, and OpenAI's advice is to contact them and confirm their setup ingests the new header.
Log what you receive for a few weeks before you act on it. The signals are still rolling out, so record which Forwarded fields arrive, which requests are signed, and what ipstack says about the socket address. Then set your rules from your own numbers and not from our 12.
#Wrapping Up
The check works because it asks two separate questions: is this really ChatGPT, and where is the person behind it. The signature answers the first, and the Forwarded header plus an IP lookup answers the second. You can get a free key at ipstack.com, and compare it with other IP APIs on its Public APIs page.
Happy building.