How to Verify Googlebot by IP and Spot Fake Googlebots
How to verify Googlebot, AdsBot and Google-Agent by IP: reverse and forward DNS, Google's range files, and real lookups of true and fake Google crawlers.

The same method covers AdsBot (special-crawlers.json) and Google-Agent (user-triggered-agents.json), with one catch each: an AdsBot hit is a page check, never an ad click, and Google-Agent can arrive from a Google network outside AS15169.
The User-Agent is the part an impostor controls. In a 14-day test on one new site published by Search Engine Journal, only 107 of 799 requests calling themselves Googlebot came from a verified Google address. That's one small site, so read it as a warning, not a rate. Below is the manual check, the automated one, and a real lookup of a true and a fake Googlebot side by side.

Why a Googlebot User-Agent proves nothing
A User-Agent string is a claim the client makes about itself, and any client can send any string. Scrapers copy Googlebot's because many sites treat it kindly: no rate limits, no login walls, no bot challenges. That makes the name a disguise worth wearing.
The cost of believing it runs both ways. Let a fake Googlebot through and a scraper gets your content at crawler speed (our guide to detecting scraping bots in your access logs shows what that looks like). Block a real one by mistake and your pages drop out of Google's index. The fix is the same for both: verify the address. Our broader guide to verifying AI crawlers by IP covers GPTBot, ClaudeBot and signed agents, and our comparison of OpenAI's main bots, GPTBot, OAI-SearchBot and ChatGPT-User covers which of them to block; this post covers Google's crawlers only.
How to verify Googlebot manually: reverse DNS, then forward DNS
Google documents a two-step DNS check, and both steps matter. Here it is on a real Googlebot address, run again on 2026-11-19:
Step 1 is the reverse lookup, which asks what hostname the IP claims. Step 2 is the forward lookup, which asks whether that hostname points back to the same IP.
$ dig +short -x 66.249.66.1
crawl-66-249-66-1.googlebot.com.
$ dig +short crawl-66-249-66-1.googlebot.com
66.249.66.1
The hostname ends in googlebot.com and resolves back to the original IP, so the request came from Google. Skipping step 2 is the common mistake. Whoever controls an IP also controls its reverse DNS record, so a scraper can name its own server crawl-fake.googlebot.com. It can't make Google's DNS point that name back at its server. The forward lookup is what makes the check unforgeable.
This works well for one address you're investigating. It's slow for a busy log, because every new IP needs two DNS queries, and DNS failures turn into false "fakes".
Googlebot IP ranges: three crawler types, three range files
Google's crawlers fall into three groups, and each has its own hostnames and its own published IP list. Matching an IP against the right file is the automated version of the DNS check, and it's how most verification at scale is done.
Common crawlers
- Examples: Googlebot
- Reverse DNS looks like: crawl-.googlebot.com or geo-crawl-.geo.googlebot.com
- Range file: common-crawlers.json
- Obeys robots.txt: Always, for automatic crawls
Special-case crawlers
- Examples: AdsBot, Mediapartners-Google, APIs-Google, Google-Safety
- Reverse DNS looks like: rate-limited-proxy-*.google.com
- Range file: special-crawlers.json
- Obeys robots.txt: May or may not
User-triggered fetchers
- Examples: Google Site Verifier, Google-Agent, fetches requested by a user
- Reverse DNS looks like: .gae.googleusercontent.com or google-proxy-.google.com
- Range file: user-triggered-fetchers.json, user-triggered-fetchers-google.json, user-triggered-agents.json
- Obeys robots.txt: Generally not, a user asked for the fetch
All five files live under https://developers.google.com/static/crawling/ipranges/. Note the /static/ part: that is the path Google's verification page links to, and it answered 200 for every file when we fetched them on 2026-11-19. The old googlebot.json URL answers with a 301 redirect to /static/crawling/ipranges/common-crawlers.json, so code that doesn't follow redirects silently gets nothing.
Google's verification page states no update schedule. All five files we fetched on 2026-11-19 carried a creationTime of 2026-11-18, the day before. Their sizes that day:
- common-crawlers.json: 317 prefixes, 170 IPv4
- special-crawlers.json: 272 prefixes, 136 IPv4
- user-triggered-fetchers.json: 1,088 prefixes, 544 IPv4
- user-triggered-fetchers-google.json: 504 prefixes, 252 IPv4
- user-triggered-agents.json: 20 prefixes, 12 IPv4
common-crawlers.json had the same 317 and 170 on 2026-10-05, so the count can hold steady while the date moves. Cache the files, but refresh them at least daily. For Google's addresses in general, not only crawlers, Google points to a separate file, https://www.gstatic.com/ipranges/goog.json.
Source for the list above: Google's Verify requests from Google crawlers and fetchers page.
A real Googlebot and a fake one, side by side
The quickest way to see the difference is to look up both addresses. We ran two lookups on 2026-11-19 (results change as ranges move). The first is 66.249.66.1, the Googlebot address from Google's own documentation. The second is 104.248.50.21, a DigitalOcean server: imagine your log shows it sending a Googlebot User-Agent.
[
{
"ip": "66.249.66.1",
"asn": { "asn": 15169, "org": "GOOGLE - Google LLC", "asn_type": "hosting", "user_type": "search_engine_spider" },
"detection": { "is_hosting": true, "is_vpn": false, "is_proxy": false, "is_tor": false },
"threat": {
"is_crawler": true,
"crawler": {
"verified": true,
"name": "Googlebot",
"operator": "Google",
"category": "search_engine",
"verification_method": "ip_range_list"
}
},
"scoring": { "fraud_score": 0, "recommended_action": "allow" }
},
{
"ip": "104.248.50.21",
"asn": { "asn": 14061, "org": "DIGITALOCEAN-ASN - DigitalOcean, LLC", "asn_type": "hosting", "user_type": "hosting" },
"detection": { "is_hosting": true, "is_vpn": false, "is_proxy": false, "is_tor": false },
"threat": {
"is_crawler": false,
"crawler": { "verified": false, "name": "none", "verification_method": "none" }
},
"scoring": { "fraud_score": 15, "recommended_action": "allow" }
}
]
The first address is inside Google's range list, so threat.crawler.verified is true and verification_method says how: ip_range_list. The verified-crawler match pulls its fraud_score to 0. The second is an ordinary cloud server. It isn't a crawler of any kind, so a request from it carrying a Googlebot User-Agent is a fake by definition.
Notice what the score does not do. The fake scores 15, allow, because a cloud server on its own isn't malicious. The verdict "fake Googlebot" comes from combining two facts: your log says Googlebot, the lookup says not Google. The API sees the IP, not your headers, so that comparison is yours to make:
const claimsGooglebot = /Googlebot/i.test(req.headers["user-agent"] ?? "");
const res = await fetch(`https://api.geoiphub.com/v1/lookup/${clientIp}`, {
headers: { "x-api-key": process.env.GEOIPHUB_KEY },
});
const ip = await res.json();
const isRealGoogle = ip.threat.crawler.verified && ip.threat.crawler.operator === "Google";
const treatment = claimsGooglebot && !isRealGoogle ? "challenge" : "normal";
A challenge here means an ordinary unverified bot: rate-limit it or put a bot check in front of it.
You can try both addresses with a Googlebot user agent in the free Googlebot IP checker without a key.
AdsBot-Google: a special-case crawler that is never an ad click
AdsBot is the crawler Google Ads uses to look at the pages your ads point to. Google's special-case crawlers page says its crawl preferences "affect Google Ads' ability to check web page ad quality." It comes in two forms:
- AdsBot-Google: User-Agent
AdsBot-Google (+http://www.google.com/adsbot.html), robots.txt tokenAdsBot-Google - AdsBot-Google-Mobile: an Android Chrome User-Agent that contains
(compatible; AdsBot-Google-Mobile; +http://www.google.com/mobile/adsbot.html), tokenAdsBot-Google-Mobile
Two rules make AdsBot different from Googlebot. First, for both forms Google says "The global user agent (*) is ignored." A Disallow: / under User-agent: * does not stop AdsBot. Only a group that names AdsBot-Google does, and that limits the ad-quality check Google describes. Second, AdsBot does not crawl from Googlebot's addresses. Its reverse DNS follows the mask rate-limited-proxy-***-***-***-***.google.com and its addresses are in special-crawlers.json.
We checked the first IPv4 host of one of that file's prefixes on 2026-11-19. dig -x 108.177.2.1 returned rate-limited-proxy-108-177-2-1.google.com, and the forward lookup of that name returned 108.177.2.1. Our API agreed:
{
"ip": "108.177.2.1",
"asn": { "asn": 15169, "org": "GOOGLE - Google LLC" },
"threat": {
"is_crawler": true,
"crawler": {
"verified": true,
"name": "GoogleSpecialCrawler",
"operator": "Google",
"category": "search_engine",
"verification_method": "ip_range_list"
}
},
"scoring": { "fraud_score": 0, "recommended_action": "allow" }
}
Read the name carefully: GoogleSpecialCrawler, not AdsBot. That is the honest limit of IP verification here. special-crawlers.json is shared by every active special-case crawler: AdsBot, Mediapartners-Google, APIs-Google and Google-Safety. The address proves the request came from Google's special-crawler family. It can't say which member sent it. Only after the IP verifies can you trust the User-Agent to tell AdsBot apart from the others.
That matters most in ad reporting. An AdsBot request is Google fetching your landing page, not a person clicking your ad. If your click logging counts every landing-page hit that carries ad parameters, verified AdsBot hits will inflate it. Filter them out before you count paid clicks, and never report them as click fraud. Our guide to detecting click fraud by IP address shows what the click side of that analysis looks like. An AdsBot User-Agent from an address outside special-crawlers.json is a different story: treat it like any other fake Google crawler.
Google-Agent: user-triggered actions from their own IP file and ASN
Google-Agent is the name Google gives to agents acting for a person. In Google's words on its Google-Agent page, "Google-Agent is used by agents hosted on Google infrastructure to navigate the web and perform actions upon user request." The page names no product, and neither do we.
The desktop User-Agent is a Chrome string with the agent's name inside it:
Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; Google-Agent; +https://developers.google.com/crawling/docs/crawlers-fetchers/google-agent) Chrome/W.X.Y.Z Safari/537.36
A mobile variant uses an Android Chrome string with the same compatible; Google-Agent part. Google-Agent is a user-triggered fetcher, and Google says those "generally ignore robots.txt rules", because a person asked for the visit. A robots.txt rule won't keep it out. If you need to control it, do it with verification and your own access rules.
Its addresses are in user-triggered-agents.json. The copy created on 2026-11-18 lists 20 prefixes, 12 of them IPv4: 136.121.16.0/24, 136.121.24.0/21, 136.121.40.0/21, 136.122.0.0/16, and eight /28 blocks in 74.125.232.0/24. We looked up one address from each part on 2026-11-19. Reverse DNS gave google-proxy-74-125-232-1.google.com and google-proxy-136-122-0-1.google.com, and both names forward-resolved to the same IPs. That is Google's mask for user-triggered fetchers acting for a user, google-proxy-***.google.com. The API returned:
[
{
"ip": "74.125.232.1",
"asn": { "asn": 15169, "org": "GOOGLE - Google LLC" },
"threat": {
"is_crawler": true,
"crawler": { "verified": true, "name": "GoogleUserTriggeredAgent", "operator": "Google", "category": "ai", "verification_method": "ip_range_list" }
},
"scoring": { "fraud_score": 0, "recommended_action": "allow" }
},
{
"ip": "136.122.0.1",
"asn": { "asn": 396178, "org": "G-CLOUD-AGENT-TRAFFIC - Google LLC" },
"threat": {
"is_crawler": true,
"crawler": { "verified": true, "name": "GoogleUserTriggeredAgent", "operator": "Google", "category": "ai", "verification_method": "ip_range_list" }
},
"scoring": { "fraud_score": 0, "recommended_action": "allow" }
}
]
The second result is the one to remember. 136.122.0.1 is a verified Google agent, but it sits in AS396178, a separate Google network named G-CLOUD-AGENT-TRAFFIC, not AS15169. A rule that trusts "Google" by checking for AS15169 would miss it. The range file catches both.
Google is also trying a second proof. Its page says "Google is also experimenting with the Web Bot Auth protocol, using the https://agent.bot.goog identity." A signed request can name that identity, but not every request is signed, so the IP check stays the baseline.
With AdsBot and Google-Agent in the picture, one label per request keeps reporting honest:
const c = ip.threat.crawler;
const ua = req.headers["user-agent"] ?? "";
const label = !c.verified || c.operator !== "Google" ? (/Google/i.test(ua) ? "fake-google" : "other")
: c.name === "GoogleSpecialCrawler" && /AdsBot-Google/.test(ua) ? "adsbot"
: c.name === "GoogleUserTriggeredAgent" ? "google-agent"
: c.name;
adsbot rows stay out of paid-click counts, google-agent rows are a person's request carried out by Google, and fake-google rows get the treatment in the next section.
What to do with a fake Googlebot
Treat a failed check as "unverified bot", not as an attack. The request is from someone pretending to be Google, which tells you they want crawler treatment. Remove that treatment and handle them like any other automated client.
- Drop the crawler allowances. No bypass of rate limits, paywalls or bot challenges for a Googlebot name that didn't verify.
- Rate-limit by network, not by address. Scrapers rotate IPs inside one provider. For IPv6 sources, key on the prefix, as in our guide to rate-limiting IPv6 by /64 prefix.
- Never block a verified Google address by accident. Run the verification before any blocklist rule, so a broad hosting or ASN block can't catch the real Googlebot.
- Verify the real client IP. Use the connecting address, or a forwarding header only when your own proxy or CDN sets it. A client can write anything into
X-Forwarded-For, including a real Googlebot address. - Fail open on DNS errors. If the reverse lookup times out, that's not proof of a fake. Fall back to the range file, or let the request through and check later.
- Keep the evidence. Log the claimed User-Agent, the IP and the verification result, so you can measure how much "Googlebot" traffic is real.
The same pattern applies at checkout and signup, where automated agents increasingly claim to be well-known bots. Our guide to blocking AI shopping-agent fraud at checkout shows how a verified or unverified crawler flag fits into a payment decision. For the other bot classes an IP lookup can and can't identify, see our overview of what IP data reveals about a bot.
Where IP verification falls short
Range matching tells you an address belongs to Google's crawlers. It has limits worth knowing before you rely on it.
- We cover all of Google's files, each under its own name. GeoIPHub verifies crawlers from 19 official range feeds, including all five Google files in the list above: common crawlers, special-case crawlers and the three user-triggered files. Each file has its own name. On 2026-11-19,
107.178.192.1from user-triggered-fetchers.json returnedverified: truewithname: "GoogleUserTriggeredFetcher", notGooglebot, and the special-crawlers.json and user-triggered-agents.json addresses above came back asGoogleSpecialCrawlerandGoogleUserTriggeredAgent. Checkthreat.crawler.name, not onlyverified. - There can be a short lag. Google states no update schedule for its files. We re-fetch them daily and rebuild our lookup database daily, so a brand-new Google prefix can take up to about two days to verify through us. The DNS check has no lag.
- Run your own DNS check when you need the hostname. Our record for these Google addresses doesn't carry the reverse DNS name that
digreturns, such ascrawl-66-249-66-1.googlebot.com. The verdict comes from the range list, which is the reliable path, so usedigfor the hostname, as we did above. - Signed requests are coming, but not for Googlebot yet. Google is testing Web Bot Auth, which lets an agent cryptographically sign its requests, for Google-Agent as shown above. It doesn't sign every request, and Google says to fall back to the established checks above. Our AI crawler verification guide covers how to verify a signature.
- A bare googleusercontent.com match is too loose. Google Cloud customers' addresses reverse-resolve under that domain too: one of ClaudeBot's resolves to a
bc.googleusercontent.comname and forward-confirms, as we show in how to verify ClaudeBot, PerplexityBot, Bingbot and Applebot. Match the full pattern for the crawler class, such as.gae.googleusercontent.comfor user-triggered fetchers. - A real Google address isn't always Googlebot. Google's network, AS15169, also carries services such as Google Public DNS (
8.8.8.8), which our lookup scores as plain hosting, not a crawler. And Google-Agent also uses AS396178. Only the crawler range files count, so never allowlist a Google ASN as a whole.
Start with one number from your own logs: how many requests last week claimed to be Googlebot, and how many of those IPs pass the forward-confirmed DNS check. The gap between the two is your fake-Googlebot traffic, and it's usually bigger than people expect.
Frequently Asked Questions
What is Googlebot's IP address?
Googlebot has no single IP address. It crawls from many prefixes that Google publishes in common-crawlers.json, with no stated update schedule; the copy we fetched on 2026-11-19, created on 2026-11-18, listed 317 prefixes, 170 of them IPv4. 66.249.66.1, the example in Google's own documentation, is one of them. Always check an address against the current file instead of a hard-coded list.
How do I verify that a request is really from Googlebot?
Check the IP, not the User-Agent. Run a reverse DNS lookup on the IP and confirm the hostname matches Google's pattern for that crawler class (googlebot.com for Googlebot, rate-limited-proxy-*.google.com for special-case crawlers such as AdsBot, google-proxy-*.google.com or gae.googleusercontent.com for user-triggered fetchers), then run a forward lookup on that hostname and confirm it returns the same IP. At scale, match the IP against Google's published range files instead, starting with common-crawlers.json for Googlebot.
Where does Google publish Googlebot's IP ranges?
In five JSON files under https://developers.google.com/static/crawling/ipranges/, linked from Google's 'Verify requests from Google crawlers and fetchers' page. Googlebot and the other common crawlers are in common-crawlers.json, and the old googlebot.json address returns a 301 redirect to that file. AdsBot and the other special-case crawlers are in special-crawlers.json, Google-Agent is in user-triggered-agents.json, and other user-triggered fetchers have two files of their own.
Is every Google IP a Googlebot IP?
No. Google's network (AS15169) also carries other Google services, such as Google Public DNS at 8.8.8.8. Only addresses inside the crawler range files are Google crawlers, so an ASN allowlist is too broad. In our lookup, 66.249.66.1 verified as Googlebot while a DigitalOcean server claiming the same name did not.
Should I block requests that claim to be Googlebot but fail verification?
Treat them as an ordinary unverified client, not as Googlebot. Rate-limit or challenge them like any other bot. Don't give them the crawl allowances you give the real Googlebot, and check that your own rules can never block a verified Google address.
Is an AdsBot-Google visit an ad click?
No. AdsBot is the crawler Google Ads uses to check web page ad quality, so a hit in your logs is Google fetching the page, not a person clicking an ad. Don't count verified AdsBot requests as paid clicks or as click fraud. Verify the IP against special-crawlers.json first, because anyone can send the AdsBot User-Agent.
What is Google-Agent?
Google says Google-Agent 'is used by agents hosted on Google infrastructure to navigate the web and perform actions upon user request.' Its User-Agent contains 'compatible; Google-Agent', and it uses the addresses in user-triggered-agents.json, which listed 20 prefixes (12 IPv4) in the copy created on 2026-11-18. Like other user-triggered fetchers it generally ignores robots.txt, because a user asked for the action.
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.


