AI Shopping Agent Fraud at Checkout: How to Stop Bot Fraud by IP Without Blocking Real Sales
AI shopping agent fraud at checkout: a verified ChatGPT-User address scored 0 and a plain cloud server 10 in our lookups. Verify the agent, then score the IP.

Your best-converting checkout traffic and your costliest fraud now arrive from the same kinds of networks. Adobe found AI traffic to US retail sites "converted 42% better" than human visitors in March 2026, a year after it converted 38% worse (Adobe data via TechCrunch). Meanwhile automated traffic passed 53% of all web traffic in 2025 (Imperva 2026 Bad Bot Report).
HUMAN Security reports that "2.3% of agentic activity now occurs on checkout pages", and that "only one half of one percent separates" the rate of benign automation from malicious automation (HUMAN, March 2026). Behaviour alone won't sort them.
Below are four real lookups, why the User-Agent match is your job, and a score-to-action map that keeps real agent sales.

Why blocking datacenter and proxy IPs at checkout fails both ways
A blanket datacenter block fails because it is both leaky and costly. It is leaky because the expensive attacks don't need a datacenter address. HUMAN says "Carding volume has surged 250% since 2022" and "Post-login account compromise attempts more than quadrupled year over year" (HUMAN). GeoIPHub does not detect residential proxies, so fraud from home connections has to be caught by your velocity and payment data. Our explainer on residential proxy fraud covers why.
It is costly because it hits people you want to sell to:
- Real agents run on cloud networks. The verified ChatGPT-User address below sits on Microsoft's AS8075 and is flagged
datacenter_ip. - Apple iCloud Private Relay users share relay egress addresses run on partner networks such as Cloudflare.
- Carrier-grade NAT puts many subscribers behind one address. RFC 6598 reserves
100.64.0.0/10as shared address space for it. Cloudflare measured that "CGNAT IPs are subject to rate limiting three times more often than non-CGNAT IPs", while the mean bot rate was lower for CGNAT addresses, 7% against 13.1% (Cloudflare).
So connection type is a weighted input, never a hard decline. Our hub on bot detection by IP shows what each IP flag can and can't prove, with five real lookups.
Four checkout callers, four lookups: what we saw on 2026-10-23
A verified agent address scores 0 and allow, and so does almost any cloud server. We ran four keyless lookups between 05:03:52 and 05:04:07 UTC on 23 October 2026, each 5 seconds apart:
- ChatGPT-User:
104.208.184.193, the first host of104.208.184.192/28, the first prefix in OpenAI's chatgpt-user.json. We fetched the file at 05:03 UTC. It listed 234 IPv4 prefixes, no IPv6, with acreationTimeof 2026-10-20. - Google user-triggered fetcher:
107.178.192.1, inside107.178.192.0/27in Google'suser-triggered-fetchers.json. - Plain cloud server:
45.33.32.156,scanme.nmap.org, a public test host on Linode. It is not an agent. - iCloud Private Relay:
104.28.46.99, an Apple relay egress address on Cloudflare.
ChatGPT-User, 104.208.184.193
crawler.verified/name/category: true / ChatGPTUser / aifraud_score: 0recommended_action: allow- Checkout decision: Honour as the buyer's agent
Google fetcher, 107.178.192.1
crawler.verified/name/category: true / GoogleUserTriggeredFetcher / fetcherfraud_score: 0recommended_action: allow- Checkout decision: Honour
Cloud server, if it claimed to be an agent, 45.33.32.156
crawler.verified/name/category: false / none / nonefraud_score: 10recommended_action: allow- Checkout decision: Step up
Private Relay, 104.28.46.99
crawler.verified/name/category: false / none / nonefraud_score: 9recommended_action: allow- Checkout decision: Honour
Here is the ChatGPT-User lookup, trimmed, with nesting kept and values unedited:
{
"ip": "104.208.184.193",
"asn": {
"asn": 8075,
"org": "MICROSOFT-CORP-MSN-AS-BLOCK - Microsoft Corporation",
"asn_type": "hosting",
"connection_type": "datacenter"
},
"detection": {
"is_hosting": true
},
"threat": {
"is_crawler": true,
"crawler": {
"verified": true,
"name": "ChatGPTUser",
"operator": "OpenAI",
"category": "ai",
"verification_method": "ip_range_list"
}
},
"scoring": {
"fraud_score": 0,
"recommended_action": "allow",
"detection_methods": ["datacenter_ip", "no_ptr_datacenter", "verified_crawler"]
}
}
Two hosting signals fired, datacenter_ip and no_ptr_datacenter. The exonerating verified_crawler signal pulled the total to 0. This address has no reverse DNS, live or stored, so OpenAI's range file is the only proof. The Google fetcher shows the same pattern at 0, except that its hostname resolves, so rdns_hosting fires instead of no_ptr_datacenter.
The cloud server is the entry that matters. Its 10 comes from datacenter_ip alone, inside the allow band (25 or less). If that request had arrived with a ChatGPT-User User-Agent, the score would still say allow. Only verified: false and name: "none" show that the claim is false. That is why its checkout decision is step up, not allow.
The relay address scored 9 with relay_ip as the only method. Relays are capped at 60, so a Private Relay user can never reach block. Our geolocation says Luanda, Angola, but Apple's egress feed said Lusaka, Zambia when we checked on 2026-10-12, so judge relay users by country.
At 05:09 UTC we also looked up 136.121.16.1, the first IPv4 host in Google's user-triggered-agents.json. That file covers Google-Agent, which Google says "is used by agents hosted on Google infrastructure to navigate the web and perform actions upon user request" (Google). It came back verified as GoogleUserTriggeredAgent, score 0, allow. It also fired fcrdns_mismatch, though a live dig forward-confirms its hostname. That is our bug; it did not move the score, and we have logged it.
These are five lookups on one morning, not a benchmark. Ranges move, so re-run them before you copy a value.
The User-Agent match is your code's job, not the API's
The API proves which bot owns an address, and your code proves the request claimed that same bot. An IP lookup never sees the User-Agent, so GeoIPHub can't flag a spoofed agent by itself. Your checkout handler holds the header and has to compare it.
Names differ between the two sides. OpenAI's User-Agent token is ChatGPT-User, and the API returns ChatGPTUser without the hyphen. Google's token is Google-Agent, and the API returns GoogleUserTriggeredAgent. A literal string compare fails, so keep a small map:
// User-Agent token mapped to threat.crawler.name as the API returns it (seen 2026-10-23)
const AGENT_NAMES = {
"ChatGPT-User": "ChatGPTUser",
"Google-Agent": "GoogleUserTriggeredAgent",
};
// Returns null when the request makes no agent claim,
// true when the claim matches a verified range, false when it doesn't.
function agentClaimHolds(userAgent, lookup) {
const token = Object.keys(AGENT_NAMES).find((t) => userAgent.includes(t));
if (!token) return null;
const c = lookup.threat.crawler;
return c.verified === true && c.name === AGENT_NAMES[token];
}
A false result is the cloud-server entry above: step it up or refuse it, whatever the score. The full nginx and Express enforcement, with a spoofed-GPTBot test, is in our guide on whether to block AI crawlers.
Verify the agent's signature before you score its IP
A valid protocol credential or signature outranks any IP signal. Three mechanisms answer "who sent this" more firmly than a range file.
Agentic Commerce Protocol (ACP). Stripe announced ACP on September 29, 2025 as an open standard "codeveloped by Stripe and OpenAI"; the spec repository is Apache-2.0 licensed. Its Agentic Checkout RFC marks an Authorization bearer token, API-Version and, on every POST, Idempotency-Key as required, with Signature and Timestamp recommended. Stripe says its Shared Payment Tokens "are scoped to a specific merchant and cart total", which limits what a stolen token can buy.
Web Bot Auth. Agents sign each request under RFC 9421 HTTP Message Signatures (Standards Track, February 2024). Cloudflare's Web Bot Auth post uses the Signature, Signature-Input and Signature-Agent headers and Ed25519 keys published by the signer.
Card-network agent programs. Visa built its Trusted Agent Protocol "in collaboration with Cloudflare" on the HTTP Message Signature standard, to distinguish trusted agents "from malicious automation and rogue bots" (Visa, October 14, 2025). Cloudflare's announcement the same day says "Mastercard is incorporating Web Bot Auth into Mastercard Agent Pay."
On an ACP call, the RFC says ChatGPT calls your checkout endpoints, so the connecting IP belongs to the agent platform, not the shopper. Verify the credential on that lane and save IP scoring for direct web traffic. Our guide to verifying AI crawlers and agents by IP, rDNS and Web Bot Auth walks through each check.
Why IP allowlists alone are brittle, even for real agents
A hand-kept allowlist breaks because agent addresses are shared and keep moving. Cloudflare puts it plainly: "the logic around IP address ranges representing a product or group of users is brittle". It adds that connections "might be shared by multiple users, such as in the case of privacy proxies and VPNs", and that cloud ranges "change over time" (Cloudflare).
OpenAI's own file shows the drift:
2026-10-06
- IPv4 prefixes in chatgpt-user.json: 230
creationTime: 2026-09-25
2026-10-23
- IPv4 prefixes in chatgpt-user.json: 234
creationTime: 2026-10-20
The 2026-10-06 count comes from our comparison of GPTBot, OAI-SearchBot and ChatGPT-User. OpenAI also says of ChatGPT-User that "Because these actions are initiated by a user, robots.txt rules may not apply" (OpenAI).
Our side lags too. GeoIPHub re-fetches 19 official range files and rebuilds its lookup database daily, so a new prefix can take up to about two days to verify. Treat a range match as strong corroboration, and prefer a signature when the agent sends one.
AI shopping agent fraud: the threats at the payment step
Three attacks drive AI shopping agent fraud at checkout, and none of them looks like a legitimate agent order of one cart for one buyer.
- Card testing (enumeration). Bursts of small or authorisation-only attempts with high decline rates. Visa says enumeration attacks cause "$1.1B annually in fraud losses", and "Thirty three percent of enumerated accounts experienced fraud within five days" (Visa, May 2024).
- Account takeover. Stolen logins used to buy with saved cards. Imperva says financial services accounted for "46% of account takeover incidents" (Imperva 2026). Our guide to account-takeover defense covers the login side.
- Scalping. Bots that hoard limited stock on high-demand drops.
Card testing spread across many addresses beats a per-IP counter, so also count declines and distinct cards per ASN and per BIN.
Map the 0 to 100 score to a checkout action
A 0 to 100 score is useful at checkout only when each band maps to a fixed action. GeoIPHub's explainable risk score covers the IP-side inputs, and scoring.detection_methods names every signal that fired. Your code and payment data supply the rest:
- Valid ACP credential or Web Bot Auth signature: Trusted lane, low friction
crawler.verifiedtrue and the name matches the User-Agent: Overrides the hosting signals- Agent User-Agent with no verified match: Step up or refuse, whatever the score
- Hosting network (
datacenter_ip): Small rise, 10 on its own today - VPN or Tor exit: Large rise, often
block - Relay (
relay_ip): Small rise, capped at 60 - Card, BIN and decline velocity per IP and per ASN: Large rise
- IP country differs from billing country: Rise, judged at country level
Then map the bands to actions:
allow
- Score: 0 to 25
- Checkout action: Pass, unless an agent claim failed verification
review
- Score: 26 to 50
- Checkout action: 3-D Secure
step_up
- Score: 51 to 75
- Checkout action: 3-D Secure, plus a velocity check
block
- Score: 76 to 100
- Checkout action: Decline or hold for manual review

Caps keep shared addresses out of block. A relay address is capped at 60, so it can't be declined by score alone, and a cap of 50 applies to addresses the API identifies as carrier-grade NAT. ACP also carries its own card-testing signal: the delegate-payment RFC sends risk_signals of type card_testing with an action of blocked, manual_review or authorized. The agent platform fills that in; your score stays a separate check. Our post on IP fraud score thresholds for login, signup and checkout tests these bands on five more addresses.
Escalate, don't block: 3-D Secure moves the liability
Send the middle bands to 3-D Secure instead of declining them, because a step up keeps the sale and usually moves the chargeback risk. Trust Payments' 3-D Secure v2 liability guide says that after successful authentication "the card issuer will be liable in the event of a fraudulent chargeback in the majority of cases". It also warns that "Successful authentication of a transaction does not guarantee the liability shift or successful authorisation."
A step up gives a real buyer a way through and makes a card tester prove they hold the card. Our guide on VPN detection false positives covers who else lands in that middle band.
The authorized-agent question is legal, not technical
The harder question is whether the agent may buy from you at all. On March 9, 2026, the US District Court for the Northern District of California granted Amazon a preliminary injunction against Perplexity. The Register reports the judge wrote that Perplexity's Comet agent "accesses with the Amazon user's permission but without authorization by Amazon" (The Register). Perplexity appealed, and on August 4, 2026 the Ninth Circuit vacated the injunction and sent the case back to the district court, where it is still open.
That ruling did not settle the question. IP checks tell you who sent the request. Your terms of service say whether that sender may buy.
Where IP checks fail at checkout
IP signals cover only part of the checkout picture, and these are the known gaps:
- No residential-proxy detection. Fraud from home connections needs your velocity and payment data.
- No User-Agent visibility. The API never flags a spoofed agent; the name match in your code does.
- Range lag and DNS gaps. A new prefix can take about two days to verify, and we saw one false
fcrdns_mismatchthis morning. - Carrier-grade NAT isn't flagged by range today. When we looked up
100.64.0.1on 2026-10-22, it did not come back marked as CGNAT. Don't build a rule on that flag yet.
After any rule change, track false positives by segment, such as iOS Safari, mobile carriers and Private Relay. Our note on how accurate IP geolocation really is explains why country beats city.
Put it in your checkout handler
Wire this in server-side at the checkout endpoint, in four steps:
- Verify any ACP credential or Web Bot Auth signature first, and give a valid one the trusted lane.
- Look up the connecting IP, as in our guide to adding IP fraud detection to your app with the free API.
- Run the User-Agent map against
threat.crawler.name. A failed agent claim gets a step up or a refusal. - Map
scoring.recommended_actionto the bands above, and add your card and ASN velocity on top.
When a decision looks wrong, use the steps in how to investigate an IP address to see why. Start with one address from your own checkout logs that claimed ChatGPT-User this week. Look it up and compare crawler.name with the claim.
FAQ
Should I block all datacenter or proxy IPs at checkout to stop bots?
No. Real agents run on cloud networks: on 2026-10-23 a verified ChatGPT-User address on Microsoft's AS8075 scored 0, allow. Blanket blocks also reject Private Relay and carrier-grade NAT users. Weigh hosting in the score and send the middle bands to 3-D Secure.
How do I tell a legitimate AI shopping agent from a fraud bot at the payment step?
Verify identity first: an ACP credential or a Web Bot Auth signature under RFC 9421. Without one, look up the IP, which returns threat.crawler.verified and the bot name, and have your code check that name against the User-Agent the request claimed.
Why is IP allowlisting alone brittle for AI agents?
Cloudflare notes that a crawling service's connections can be shared, as with privacy proxies and VPNs, and cloud ranges change over time. OpenAI's chatgpt-user.json grew from 230 to 234 IPv4 prefixes between our 2026-10-06 and 2026-10-23 fetches.
How should a 0 to 100 IP risk score map to a checkout decision?
Pass allow (25 or less), send review (50 or less) and step_up (75 or less) to 3-D Secure, and decline or hold block (above 75). An agent claim that fails verification gets a step up whatever the score.
Will stepping up to 3-D Secure hurt conversion more than blocking?
A block loses the sale for certain; a step up gives a real buyer a way through. Trust Payments says that after successful authentication the issuer is liable for a fraudulent chargeback in the majority of cases, though this is not guaranteed.
Is it legal to block AI agents from buying on my store?
It depends on authorization, and this is not legal advice. In March 2026 a federal court granted Amazon a preliminary injunction against Perplexity, whose Comet agent the judge said accessed Amazon with the user's permission but without Amazon's authorization. The Ninth Circuit vacated that injunction in August 2026, and the case is still open.
The team behind the GeoIPHub API
Written by the GeoIPHub team, the people who build the GeoIPHub IP intelligence API and its scanner. Drafts are prepared with AI assistance and edited by the team; API examples are real lookups against the live API unless labelled illustrative.


