Skip to content
Network Security

ClaudeBot IP Ranges and How to Verify PerplexityBot, Bingbot and Applebot

ClaudeBot IP ranges: 14 prefixes in one file, no reverse DNS. Verify PerplexityBot by list, Bingbot and Applebot by DNS or file. Lookups from 13 Nov 2026.

ByGeoIPHub TeamPublishedReading time16 min read
Four glass gates in a row, each with a small glass bot in front: at two gates a blue beam bounces off a tall frosted mirror panel back to the bot, and at the other two the beam runs to a glowing glass slab on the floor

107.20.236.150 is PerplexityBot. 107.20.236.151, the next address up, is not. Both reverse-resolve to an Amazon EC2 hostname that resolves back to the same address, so a reverse DNS check passes both. Only Perplexity's file tells them apart.

That matters because a User-Agent is a claim, and the names get copied. In August 2026 GreyNoise reported a cluster of scanners impersonating 13 AI crawlers from eight companies, hunting for .env files and keys: "Six of those names came from the same 824 addresses in almost identical volume". In one vendor's dataset, Trakkr's server logs (127 sites watched, 1 August to 14 October 2026) found that, of the requests whose client IP could be checked (6.7 million on 100 sites), 7.4% naming ClaudeBot and 11.7% naming PerplexityBot came from outside the operators' published addresses. One site accounted for 62% of all the fakes. These four operators don't offer the same proof. The rest of what an IP can tell you is in bot detection by IP.

ClaudeBot IP ranges: one file, 14 prefixes, three bots

Anthropic publishes ClaudeBot's IP ranges in one file, claude.com/crawling/bots.json, which on 13 November 2026 held 14 IPv4 prefixes with a creationTime of 20 October 2026; the same 14 cover Claude-User and Claude-SearchBot. The crawler page links it and says nothing about reverse DNS.

bots.json (Anthropic), fetched 13 November 2026, 07:08 UTC

  • URL: https://claude.com/crawling/bots.json
  • Covers: ClaudeBot, Claude-User, Claude-SearchBot (not labelled per bot)
  • creationTime: 2026-10-20T00:00:00Z
  • Prefixes: 14 IPv4 (one /22 and 13 single addresses), 0 IPv6
  • Reverse DNS: not documented
  • GeoIPHub returns: name "ClaudeBot", operator "Anthropic"

Anthropic's rule is short: "If a crawler has a source IP address on this list, it indicates that the crawler is coming from Anthropic." The file proves Anthropic, not which of its three bots. The User-Agent token tells you that, and GeoIPHub's API returns ClaudeBot for all three.

One Anthropic agent is not in bots.json: Claude-Agent publishes its addresses in a separate TOML file at claude.com/.well-known/sail, which listed 9 IPv4 entries on 13 November 2026. GeoIPHub does not load that file, so a Claude-Agent address returns no crawler match.

The 14 prefixes sit on two clouds: 216.73.216.0/22 is registered to Amazon (whois NetName AMAZO-4), and the 13 single addresses are on Google Cloud. An ASN rule for either cloud would let in every other tenant there, so match the exact ClaudeBot IP ranges. We looked up one address from each:

216.73.216.10 (13 November 2026, 07:09:13 UTC)

  • threat.crawler.verified: true
  • name: ClaudeBot, operator: Anthropic
  • verification_method: ip_range_list
  • asn: 16509, AMAZON-02 - Amazon.com, Inc.

34.162.230.222 (07:09:20 UTC)

  • threat.crawler.verified: true
  • name: ClaudeBot, operator: Anthropic
  • verification_method: ip_range_list
  • asn: 396982, GOOGLE-CLOUD-PLATFORM - Google LLC

Neither name helps you by DNS. dig +short -x 216.73.216.10 printed nothing (no PTR record), and 34.162.230.222 reverse-resolves to a generic Google Cloud name, 222.230.162.34.bc.googleusercontent.com.

Claude API IP addresses are not ClaudeBot's

Anthropic's API IP address page lists the addresses of the Claude API, not ClaudeBot's: none of its inbound or outbound ranges was in bots.json on 13 November 2026. Its outbound ranges are what Anthropic uses "for outbound requests (for example, when making MCP tool calls to external servers)". We looked up 160.79.104.1, inside both the inbound 160.79.104.0/23 and the outbound 160.79.104.0/21, at 07:09:29 UTC: is_crawler: false, AS399358 "ANTHROPIC - Anthropic, PBC", score 0, allow. An address can belong to Anthropic and still not be ClaudeBot.

The file also moves. Our post on whether to block each AI crawler counted 38 prefixes on 20 October, from a file dated 7 October. The file dated 20 October has 14, and we found the same 14 prefixes and date on 29 October, 9 November and 13 November.

Anthropic also warns that blocking its bots' IP addresses "may not work correctly or persistently guarantee an opt-out, as doing so impedes our ability to read your robots.txt file." Verify by IP; control by robots.txt.

PerplexityBot IP ranges: 13 single addresses, plus 10 for Perplexity-User

Perplexity publishes its IP ranges as two files of single addresses: perplexity.ai/perplexitybot.json held 13 for PerplexityBot and perplexity.ai/perplexity-user.json held 10 for Perplexity-User when we fetched them on 13 November 2026, both with a creationTime of 28 October 2026, no IPv6 and no documented reverse DNS. Every prefix in both files is a /32.

perplexitybot.json (Perplexity), fetched 13 November 2026, 07:08 UTC

  • URL: https://www.perplexity.ai/perplexitybot.json
  • Covers: PerplexityBot
  • creationTime: 2026-10-28T16:48:51
  • Prefixes: 13 IPv4 (all /32), 0 IPv6
  • Reverse DNS: not documented
  • GeoIPHub returns: name "PerplexityBot", operator "Perplexity"

perplexity-user.json (Perplexity), fetched 13 November 2026, 07:08 UTC

  • URL: https://www.perplexity.ai/perplexity-user.json
  • Covers: Perplexity-User
  • creationTime: 2026-10-28T16:48:51
  • Prefixes: 10 IPv4 (all /32), 0 IPv6
  • Reverse DNS: not documented
  • GeoIPHub returns: name "PerplexityUser", operator "Perplexity"

The crawler documentation gives the rule: "Each bot has its own IP ranges, so match each User-Agent against its own IP ranges." PerplexityBot "is not used to crawl content for AI foundation models". Of Perplexity-User it says: "Since a user requested the fetch, this fetcher generally ignores robots.txt rules."

Tracing one PerplexityBot claim from 107.20.236.151

107.20.236.151 is a stand-in: it never sent us a request. Say it shows up in your access log like this:

Output
107.20.236.151 - - [13/Nov/2026:07:00:00 +0000] "GET / HTTP/1.1" 200 5120 "-" "Mozilla/5.0 (compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)"

Reverse DNS looks fine. We ran dig at 07:09 UTC:

Output
$ dig +short -x 107.20.236.151 ec2-107-20-236-151.compute-1.amazonaws.com. $ dig +short ec2-107-20-236-151.compute-1.amazonaws.com. 107.20.236.151 $ dig +short -x 107.20.236.150 ec2-107-20-236-150.compute-1.amazonaws.com. $ dig +short ec2-107-20-236-150.compute-1.amazonaws.com. 107.20.236.150

Both forward-confirm. But 107.20.236.150 is in perplexitybot.json and .151 is not. GeoIPHub's API agrees. Trimmed responses, .151 at 07:09:44 UTC and .150 at 07:09:36 UTC:

JSON
{ "ip": "107.20.236.151", "threat": { "is_crawler": false, "crawler": { "verified": false, "unverified": false, "name": "none", "operator": "none", "category": "none", "verification_method": "none" } }, "asn": { "asn": 14618, "org": "AMAZON-AES - Amazon.com, Inc." }, "scoring": { "fraud_score": 15, "recommended_action": "allow" } }
JSON
{ "ip": "107.20.236.150", "threat": { "is_crawler": true, "crawler": { "verified": true, "unverified": false, "name": "PerplexityBot", "operator": "Perplexity", "category": "ai", "verification_method": "ip_range_list" } }, "asn": { "asn": 14618, "org": "AMAZON-AES - Amazon.com, Inc." }, "scoring": { "fraud_score": 0, "recommended_action": "allow" } }

On a cloud, reverse DNS names the cloud, not the customer. Any AWS tenant can get an ec2- name that forward-confirms.

These files change too: they held 8 and 4 addresses on 20 and 27 October, and the files dated 28 October hold 13 and 10. Perplexity says the addresses "are updated regularly and should be the source of truth for your WAF configurations".

How to verify Bingbot: reverse DNS to search.msn.com, then the file

To verify Bingbot, reverse-resolve the IP, check that the name ends in .search.msn.com, then resolve that name and check it returns the same IP. Or match the IP against bing.com/toolbox/bingbot.json, which held 29 IPv4 prefixes on 13 November 2026 under a creationTime of 3 January 2024. The DNS steps come from Bing's 2012 post, which is still live.

Output
$ dig +short -x 157.55.39.1 msnbot-157-55-39-1.search.msn.com. $ dig +short msnbot-157-55-39-1.search.msn.com. 157.55.39.1

157.55.39.1 (07:09:58 UTC)

  • threat.crawler.verified: true
  • name: Bingbot, operator: Microsoft
  • verification_method: ip_range_list
  • asn: 8075

bingbot.json (Microsoft), fetched 13 November 2026, 07:08 UTC

  • URL: https://www.bing.com/toolbox/bingbot.json
  • Covers: Bingbot
  • creationTime: 2024-01-03T10:00:00 (1,045 days old on 13 November 2026)
  • Prefixes: 29 IPv4, 0 IPv6
  • Reverse DNS: names end in .search.msn.com
  • GeoIPHub returns: name "Bingbot", operator "Microsoft"

The same post says "Bing does not publish a list of IP addresses or ranges from which we crawl the Internet." That line is out of date, but its DNS method still works. The file also changed without its date moving: our verified crawler list printed 28 prefixes on 29 October, and it has held 29 since 9 November. An unchanged date doesn't mean an unchanged list.

Check DNS first for Bing, since it doesn't depend on the file's age, and use the file for bulk checks. Bing's own web check is at www.bing.com/toolbox/verify-bingbot.

How to verify Applebot: reverse DNS to applebot.apple.com, or the file

Apple documents two ways to verify Applebot: a reverse DNS name in the applebot.apple.com domain, or a match against search.developer.apple.com/applebot.json, which held 24 IPv4 prefixes on 13 November 2026 with a creationTime of 15 September 2026. In Apple's words: "Traffic coming from Applebot is generally identified by using reverse DNS in the *.applebot.apple.com domain."

Output
$ dig +short -x 17.241.208.161 17-241-208-161.applebot.apple.com. $ dig +short 17-241-208-161.applebot.apple.com. 17.241.208.161

17.241.208.161 (07:10:05 UTC)

  • threat.crawler.verified: true
  • name: Applebot, operator: Apple, category: search_engine
  • verification_method: ip_range_list
  • asn: 714, APPLE-ENGINEERING - Apple Inc.

applebot.json (Apple), fetched 13 November 2026, 07:08 UTC

  • URL: https://search.developer.apple.com/applebot.json
  • Covers: Applebot
  • creationTime: 2026-09-15T10:00:00
  • Prefixes: 24 IPv4 (18 /24s, three /27s, three /28s), 0 IPv6
  • Reverse DNS: names end in .applebot.apple.com
  • GeoIPHub returns: name "Applebot", operator "Apple"

Apple's own example is not in Apple's file

Apple's own documentation example, 17.58.101.179, passes the reverse DNS check but was in none of applebot.json's 24 prefixes on 13 November 2026. It reverse-resolved to 17-58-101-179.applebot.apple.com, which resolved back to the same address. The reverse also happens: 17.166.192.49 is inside 17.166.192.48/28 in the file, and dig -x returned no PTR for it. Our script's lines for both:

Output
17.58.101.179 | applebot: verified | not in list | dns ok (17-58-101-179.applebot.apple.com) 17.166.192.49 | applebot: verified | in list | dns fail (no PTR)

So code both checks for Applebot and accept a pass from either. If neither passes, it isn't verified. Applebot-Extended never needs verifying. Apple says "Applebot-Extended does not crawl webpages", so it is a robots.txt token and Apple's page gives you nothing to verify for it.

Two by DNS, two by list only: how the four differ from Googlebot

Bing and Apple can be verified by reverse DNS or by file, while Anthropic and Perplexity can be verified only by file. Side by side, on 13 November 2026, with no IPv6 in any of the five files:

  • Microsoft (Bingbot): a name ending in .search.msn.com that forward-confirms, or one file of 29 IPv4 prefixes.
  • Apple (Applebot): a name ending in .applebot.apple.com that forward-confirms, or one file of 24 IPv4 prefixes; either passing verifies.
  • Anthropic (ClaudeBot, Claude-User, Claude-SearchBot): one shared file of 14 IPv4 prefixes; no hostname test documented.
  • Perplexity (PerplexityBot, Perplexity-User): two files of /32s, 13 and 10; no hostname test, and EC2 names prove nothing.
Two identical blue glass cubes reflected the same way in one frosted mirror panel, with only the left cube resting on a glowing glass slab
Reverse DNS reflects both addresses the same way. Only the list tells them apart.

Google publishes range files for each of its three crawler classes, all with IPv6, and a reverse DNS pattern for each (the full method is in how to verify Googlebot). Its verification page says to "Verify that the domain name is either googlebot.com, google.com, or googleusercontent.com." Anthropic's 222.230.162.34.bc.googleusercontent.com forward-confirms, so it passes that step as written, though Google's own table narrows user-triggered fetchers to gae.googleusercontent.com names. Test the operator's full pattern, never the bare domain.

The suffix test needs its leading dot. Check that the name ends with .search.msn.com, so xsearch.msn.com and evil-search.msn.com.example both fail. A forged PTR can't pass either, because the forward lookup must return the same IP and the forger doesn't control Microsoft's DNS.

Check a log line against all four operators in Node

This script reads <ip> <user agent> lines, picks the file for the bot the User-Agent names, and reports whether the IP is in it; for Bingbot and Applebot it also runs the DNS check. It needs Node 18 or newer and no packages.

JavaScript
import { BlockList, isIP } from "node:net"; import { promises as dns } from "node:dns"; import { createInterface } from "node:readline"; const BOTS = [ { token: "perplexity-user", file: "https://www.perplexity.ai/perplexity-user.json" }, { token: "perplexitybot", file: "https://www.perplexity.ai/perplexitybot.json" }, { token: "claude-searchbot", file: "https://claude.com/crawling/bots.json" }, { token: "claude-user", file: "https://claude.com/crawling/bots.json" }, { token: "claudebot", file: "https://claude.com/crawling/bots.json" }, { token: "applebot", file: "https://search.developer.apple.com/applebot.json", host: ".applebot.apple.com" }, { token: "bingbot", file: "https://www.bing.com/toolbox/bingbot.json", host: ".search.msn.com" }, ]; const lists = new Map(); async function loadList(url) { if (!lists.has(url)) { lists.set(url, (async () => { try { const res = await fetch(url, { headers: { "user-agent": "bot-ip-check/1.0" } }); if (!res.ok) return null; const list = new BlockList(); for (const p of (await res.json()).prefixes) { const cidr = p.ipv4Prefix ?? p.ipv6Prefix; const [net, bits] = cidr.split("/"); list.addSubnet(net, Number(bits), p.ipv4Prefix ? "ipv4" : "ipv6"); } return list; } catch { return null; } })()); } return lists.get(url); } async function dnsCheck(ip, suffix) { try { const names = await dns.reverse(ip); for (const name of names) { const n = name.toLowerCase().replace(/\.$/, ""); if (!n.endsWith(suffix)) continue; const forward = isIP(ip) === 6 ? await dns.resolve6(n) : await dns.resolve4(n); if (forward.includes(ip)) return `dns ok (${n})`; } return names.length ? `dns fail (PTR not under ${suffix.slice(1)})` : "dns fail (no PTR)"; } catch { return "dns fail (no PTR)"; } } async function check(ip, ua) { const bot = BOTS.find((b) => ua.toLowerCase().includes(b.token)); if (!bot) return "no bot claimed"; const family = isIP(ip); if (!family) return `${bot.token}: not verified (bad IP)`; const list = await loadList(bot.file); const inList = list === null ? "list unavailable" : list.check(ip, family === 6 ? "ipv6" : "ipv4") ? "in list" : "not in list"; const parts = [inList]; if (bot.host) parts.push(await dnsCheck(ip, bot.host)); const verified = inList === "in list" || parts.some((p) => p.startsWith("dns ok")); return `${bot.token}: ${verified ? "verified" : "not verified"} | ${parts.join(" | ")}`; } for await (const line of createInterface({ input: process.stdin })) { const [ip, ...rest] = line.trim().split(" "); if (ip) console.log(ip, "|", await check(ip, rest.join(" "))); }

We ran it as node verify-bots.mjs < sample.log under Node 24 on 13 November 2026 at 07:27 UTC: 14 sample lines, then two forced failures. The User-Agents are example strings built on each operator's documented token. 45.33.32.156 is Nmap's public scan host and sent no such request; 203.0.113.9 and 2001:db8::1 are documentation addresses.

Output
216.73.216.10 | claudebot: verified | in list 107.20.236.150 | perplexitybot: verified | in list 107.20.236.151 | perplexitybot: not verified | not in list 18.97.43.80 | perplexity-user: verified | in list 18.97.43.80 | perplexitybot: not verified | not in list 157.55.39.1 | bingbot: verified | in list | dns ok (msnbot-157-55-39-1.search.msn.com) 17.241.208.161 | applebot: verified | in list | dns ok (17-241-208-161.applebot.apple.com) 17.58.101.179 | applebot: verified | not in list | dns ok (17-58-101-179.applebot.apple.com) 17.166.192.49 | applebot: verified | in list | dns fail (no PTR) 45.33.32.156 | claudebot: not verified | not in list 45.33.32.156 | bingbot: not verified | not in list | dns fail (PTR not under search.msn.com) 203.0.113.9 | no bot claimed 2001:db8::1 | claudebot: not verified | not in list not-an-ip | perplexitybot: not verified (bad IP)

Line 5 is Perplexity's per-bot rule at work: 18.97.43.80 verifies as Perplexity-User and fails as a PerplexityBot claim. For the forced run we pointed bots.json at an unresolvable host and bingbot.json at a path that returns 404:

Output
216.73.216.10 | claudebot: not verified | list unavailable 157.55.39.1 | bingbot: verified | list unavailable | dns ok (msnbot-157-55-39-1.search.msn.com)

It fails closed: an unreachable file means "not verified", never "verified", and for Bing the DNS check still stands. It sends its own User-Agent on file fetches so operators can see what is fetching; all five files also answered Node's default agent on 13 November 2026. DNS answers come from your resolver, so run it against one you trust. An IPv6 claim can't verify by list, because none of the five files had IPv6 on 13 November 2026.

To merge these with the other operators' files, build a list from all 19 files. For bots that sign their requests, and for the general method, see the three ways to verify an AI crawler.

What a GeoIPHub lookup adds, and what it can't see

A GeoIPHub threat intelligence lookup tells you whether an IP is inside one of these files and which operator published it; it can't see the User-Agent, so the comparison with the claimed bot is yours. It checks 19 official range files from 10 operators, these five among them, and a match returns threat.crawler.verified: true, the file's label in name, the operator, and verification_method: "ip_range_list".

name is the file's label, not the bot that sent the request: Anthropic's three bots all return ClaudeBot, and Perplexity's return PerplexityBot or PerplexityUser. Key your policy on operator plus the User-Agent token. The API doesn't return which file matched or when it was fetched, so a prefix added very recently may not verify yet. Details are in the threat.crawler field reference.

To try one address, check an IP and a user agent in your browser. The tool looks up the IP and compares the user agent on the page, so the user agent is never sent.

Two limits apply to every method here. A request outside the file is not verified, which is not the same as fake. And a list proves only the requests that come from it.

The name in the header is a claim. For Bing and Apple, DNS can back it up; for Anthropic and Perplexity, only their files can, so fetch them fresh and fail closed. For the 29 AI bots their operators document, each with its user agent and proof as checked on 9 November 2026, see the AI crawler list.

Frequently Asked Questions

What are ClaudeBot's IP addresses?

One file, claude.com/crawling/bots.json, also covers Claude-User and Claude-SearchBot. On 13 November 2026 it held 14 IPv4 prefixes (one /22 on Amazon and 13 single addresses on Google Cloud), dated 20 October 2026, and no IPv6. Fetch the file rather than copying a list, because it went from 38 to 14 prefixes in October.

Does ClaudeBot have reverse DNS?

No. Anthropic documents none, 216.73.216.10 has no PTR record, and the Google Cloud addresses we checked resolve to generic googleusercontent.com names. Check the address against bots.json instead.

Are the Claude API IP addresses the same as ClaudeBot's?

No. None of the inbound or outbound addresses on Anthropic's API page is in bots.json. GeoIPHub returned no crawler for 160.79.104.1, an address on Anthropic's own network, on 13 November 2026.

What are PerplexityBot's IP ranges?

Perplexity publishes 13 single addresses for PerplexityBot and 10 for Perplexity-User, in two files at perplexity.ai, both dated 28 October 2026. Match each bot against its own file, as Perplexity says. Reverse DNS only shows an Amazon EC2 name.

How do I verify Bingbot?

Reverse-resolve the IP, check that the name ends in .search.msn.com, then resolve that name and check it returns the same IP. Bing also publishes bingbot.json, 29 prefixes on 13 November 2026, though its date still reads 3 January 2024.

How do I verify Applebot?

Check for a reverse DNS name under applebot.apple.com that resolves back to the IP, or a match in applebot.json. Accept either: Apple's own example address passes the DNS check but was not in the file on 13 November 2026.

Does GeoIPHub verify these four bots?

Yes, by IP. GeoIPHub loads all five files among its 19 official range files and returns verified: true with the operator for a match. It never sees the User-Agent, so your code or our verify crawler tool compares the claimed bot.

Written by

GeoIPHub Team

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.

Share this article
More articles

Related posts