Why CDN Logs Show IP Addresses Ending in .0
If every visitor IP in your CDN access log ends in .0, nothing is broken.
The CDN is zeroing the last octet before it writes the line. That single detail quietly breaks the
most common way people verify Googlebot.
What you are looking at
A raw CDN access log line usually carries the status code, timestamp, requested URL, remote IP and user agent. On several CDNs the remote IP arrives looking like this:
200|2026-11-15|66.249.74.0|/|Mozilla/5.0 (compatible; Googlebot/2.1)
An address ending in .0 is usually a network address, not a host address. A fleet of
crawlers does not live entirely on network addresses. When most of the IPs in a log end in
.0, the host has stripped the final octet for privacy before writing the record.
This is a deliberate design choice, not a fault. Truncating the last octet is a long standing anonymization technique. It keeps a log useful for traffic analysis while removing the part that most narrowly identifies a single machine.
Why it breaks crawler verification
The correct way to check whether a visit really came from Googlebot is not to read the user agent. A user agent is free text and anything can claim to be anything. The real check is the IP, tested against the list of address ranges the crawler's owner publishes.
That check assumes you have the whole IP. You do not.
Here is the problem in one example. Suppose a genuine request arrives from 74.7.175.190
and the owner publishes the block 74.7.175.128/25. That block covers
.128 through .255. The log records the address as 74.7.175.0,
which sits in the bottom half of the range. Tested against the published block, a real request now
reads as a forgery.
It depends entirely on how narrow the published blocks are
Zeroing the last octet costs you nothing if the owner publishes blocks of /24 or
wider, because the whole /24 belongs to them either way. It costs you everything once
the published blocks are narrower. Checked on 16 November 2026:
| Crawler | Published IPv4 block widths | Survives a zeroed octet? |
|---|---|---|
| Googlebot | /27, /28 | No |
| GPTBot | /24, /25, /28 | Only the /24s |
| OAI-SearchBot | /24, /25, /28 | Only the /24s |
| Bingbot | /22 through /28 | Only the wide ones |
| PerplexityBot | /32 | Effectively never |
Googlebot publishes its ranges as /27 and /28 blocks, so a zeroed address
matches only when the real address happened to sit in the first block of its /24. The
result is not a verification system. It is a coin toss that returns a confident answer.
PerplexityBot is the clearest case. It publishes single addresses as /32 entries. A
zeroed address can only ever match if the genuine address already ended in .0.
What to do instead
- Find out whether your log is truncated before you trust it. Count the share of
IPv4 addresses ending in
.0. Above roughly 80 percent, assume truncation. - Downgrade the verdict, do not fake it. On a truncated log the only honest
question is whether the crawler owns any address in that
/24. Call that result plausible. Never call it verified. - Move the test to a host that records the full address when you need proof. Origin server logs and S3 server access logging both keep the complete IP.
- Reverse DNS still works on a full address. Look up the PTR record, confirm it resolves under the owner's domain, then resolve that hostname forward and check it returns the same address.
The wider point
A verification tool that cannot tell the difference between a forged request and a truncated log is worse than no tool. It does not fail loudly. It returns a clean, specific, wrong answer, and the reader has no way to tell that from a right one.
If you are paying anyone for crawler visits, bot traffic, or indexing services, this is the first thing to settle. Check what your logs actually contain before you check anyone's invoice against them.