AIクローラーの本物と偽物を見分ける実装。OpenAI・Anthropic・Perplexity・Googleが公開しているIPアドレスの範囲と照らし合わせるモジュールを、Cloudflare Pages Functions向けに書き、実際の範囲と偽のIPでテストした

// 各社が公開しているクローラーのIP範囲（JSON）を取ってきて、1つのファイル bot-ranges.json にまとめる
// 使い方: node fetch-ranges.mjs   （ビルドの前に流し、できたファイルを Functions から import する）
import { writeFile } from "node:fs/promises";

const SOURCES = {
  google: "https://developers.google.com/static/crawling/ipranges/common-crawlers.json",
  gptbot: "https://openai.com/gptbot.json",
  "oai-searchbot": "https://openai.com/searchbot.json",
  "chatgpt-user": "https://openai.com/chatgpt-user.json",
  anthropic: "https://claude.com/crawling/bots.json",
  perplexitybot: "https://www.perplexity.ai/perplexitybot.json",
  "perplexity-user": "https://www.perplexity.ai/perplexity-user.json",
};

const out = {};
for (const [key, url] of Object.entries(SOURCES)) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`${key}: HTTP ${res.status}（前回のファイルを残すため、書き出さずに止める）`);
  const json = await res.json();
  const prefixes = (json.prefixes ?? []).map((p) => p.ipv4Prefix ?? p.ipv6Prefix).filter(Boolean);
  if (prefixes.length === 0) throw new Error(`${key}: 範囲が0件（形式が変わった可能性）`);
  out[key] = { source: url, creationTime: json.creationTime ?? "", prefixes };
  console.log(`${key.padEnd(16)} ${String(prefixes.length).padStart(4)}件  ${json.creationTime ?? ""}`);
}
await writeFile(new URL("./bot-ranges.json", import.meta.url), JSON.stringify(out));

google            317件  2026-10-02T14:46:11.000000
gptbot             18件  2026-09-22T02:00:07.000000
oai-searchbot      39件  2026-01-02T11:00:00.000000
chatgpt-user      230件  2026-09-25T18:04:57.257335
anthropic          28件  2026-10-02T00:00:00Z
perplexitybot       8件  2025-02-07T16:56:00.000000
perplexity-user     4件  2025-10-17T10:17:00.000000

// User-Agent で名乗ったクローラーが、その会社の公開しているIP範囲から来ているかを確かめる
// Cloudflare Pages Functions（Workers）でも Node でも、そのまま動く（依存なし）

// 名乗り（User-Agent）と、照合に使う範囲の対応。上から順に見る
export const BOTS = [
  { name: "OAI-SearchBot", ua: /oai-searchbot/i, ranges: ["oai-searchbot"] },
  { name: "ChatGPT-User", ua: /chatgpt-user/i, ranges: ["chatgpt-user"] },
  { name: "GPTBot", ua: /gptbot/i, ranges: ["gptbot"] },
  // Anthropic は ClaudeBot・Claude-User・Claude-SearchBot の3つで1つのリスト
  { name: "Claude-SearchBot", ua: /claude-searchbot/i, ranges: ["anthropic"] },
  { name: "Claude-User", ua: /claude-user/i, ranges: ["anthropic"] },
  { name: "ClaudeBot", ua: /claudebot/i, ranges: ["anthropic"] },
  { name: "Perplexity-User", ua: /perplexity-user/i, ranges: ["perplexity-user"] },
  { name: "PerplexityBot", ua: /perplexitybot/i, ranges: ["perplexitybot"] },
  { name: "Googlebot", ua: /googlebot/i, ranges: ["google"] },
];

// "1.2.3.4" や "2001:db8::1" を [版, BigInt] にする。読めなければ null
export function parseIp(ip) {
  if (typeof ip !== "string") return null;
  ip = ip.trim();
  // IPv4 を IPv6 の形で書いたもの（::ffff:1.2.3.4）は IPv4 として扱う
  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i.exec(ip);
  if (mapped) ip = mapped[1];
  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
    const p = ip.split(".").map(Number);
    if (p.some((n) => n > 255)) return null;
    return [4, p.reduce((acc, n) => (acc << 8n) + BigInt(n), 0n)];
  }
  if (!ip.includes(":") || !/^[0-9a-f:]+$/i.test(ip)) return null;
  const halves = ip.split("::");
  if (halves.length > 2) return null;
  const head = halves[0] ? halves[0].split(":") : [];
  const tail = halves.length === 2 && halves[1] ? halves[1].split(":") : [];
  const fill = halves.length === 2 ? 8 - head.length - tail.length : 0;
  if (fill < 0 || (halves.length === 1 && head.length !== 8)) return null;
  const groups = [...head, ...Array(fill).fill("0"), ...tail];
  if (groups.some((g) => g.length === 0 || g.length > 4)) return null;
  return [6, groups.reduce((acc, g) => (acc << 16n) + BigInt(parseInt(g, 16)), 0n)];
}

// "20.171.206.0/24" を { v, net, mask } にする
function parseCidr(cidr) {
  const [addr, bitsStr] = cidr.split("/");
  const parsed = parseIp(addr);
  if (!parsed) return null;
  const [v, n] = parsed;
  const total = v === 4 ? 32 : 128;
  const bits = bitsStr === undefined ? total : Number(bitsStr);
  if (!Number.isInteger(bits) || bits < 0 || bits > total) return null;
  const mask = bits === 0 ? 0n : ((1n << BigInt(bits)) - 1n) << BigInt(total - bits);
  return { v, net: n & mask, mask };
}

// bot-ranges.json の形 { key: { prefixes: [...] } } を、照合しやすい形に一度だけ変換する
export function compileRanges(json) {
  const table = {};
  for (const [key, { prefixes }] of Object.entries(json)) {
    table[key] = prefixes.map(parseCidr).filter(Boolean);
  }
  return table;
}

export function ipInRanges(ip, list) {
  const parsed = parseIp(ip);
  if (!parsed || !list) return false;
  const [v, n] = parsed;
  return list.some((r) => r.v === v && (n & r.mask) === r.net);
}

// 戻り値: null（クローラーを名乗っていない）か、{ bot, verified }
// verified: true＝公開範囲の中から来た、false＝名乗っているのに範囲の外から来た
export function classify(ua, ip, table) {
  const hit = BOTS.find((b) => b.ua.test(ua || ""));
  if (!hit) return null;
  const verified = hit.ranges.some((key) => ipInRanges(ip, table[key]));
  return { bot: hit.name, verified };
}

// 実際に取ってきた bot-ranges.json と、偽物のIP（文書用に予約されたアドレス）で確かめる
import { test } from "node:test";
import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";
import { parseIp, compileRanges, ipInRanges, classify } from "./bot-verify.js";

const raw = JSON.parse(await readFile(new URL("./bot-ranges.json", import.meta.url), "utf8"));
const table = compileRanges(raw);

// 範囲の先頭と末尾のアドレスを文字列で作る（末尾＝ホスト部をすべて1にしたもの）
function edges(cidr) {
  const [addr, bits] = cidr.split("/");
  const [v, n] = parseIp(addr);
  const total = v === 4 ? 32 : 128;
  const last = n | ((1n << BigInt(total - Number(bits))) - 1n);
  const fmt = (x) => v === 4
    ? [24n, 16n, 8n, 0n].map((s) => String((x >> s) & 255n)).join(".")
    : Array.from({ length: 8 }, (_, i) => ((x >> BigInt(112 - 16 * i)) & 0xffffn).toString(16)).join(":");
  return [fmt(n), fmt(last)];
}

// UA の全文は、各社のページに載っているもの
const UA = {
  GPTBot: "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot",
  "OAI-SearchBot": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36; compatible; OAI-SearchBot/1.4; +https://openai.com/searchbot",
  "ChatGPT-User": "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot",
  // Anthropic のページには UA の全文が載っていないので、名前だけを入れた仮の文字列
  ClaudeBot: "Mozilla/5.0 (compatible; ClaudeBot)",
  PerplexityBot: "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)",
  "Perplexity-User": "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Perplexity-User/1.0; +https://perplexity.ai/perplexity-user)",
  Googlebot: "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
};
const KEY = { GPTBot: "gptbot", "OAI-SearchBot": "oai-searchbot", "ChatGPT-User": "chatgpt-user", ClaudeBot: "anthropic", PerplexityBot: "perplexitybot", "Perplexity-User": "perplexity-user", Googlebot: "google" };

// 公開されているすべての範囲について、先頭と末尾のアドレスが「本物」になること
for (const [bot, key] of Object.entries(KEY)) {
  test(`${bot}: 公開範囲 ${raw[key].prefixes.length} 件の先頭と末尾がすべて本物になる`, () => {
    for (const cidr of raw[key].prefixes) {
      for (const ip of edges(cidr)) {
        assert.deepEqual(classify(UA[bot], ip, table), { bot, verified: true }, `${cidr} の ${ip}`);
      }
    }
  });
}

test("名乗りは本物でも、文書用のアドレスから来たら偽物になる", () => {
  for (const ip of ["192.0.2.10", "198.51.100.7", "203.0.113.45", "2001:db8::1"]) {
    for (const bot of Object.keys(UA)) assert.equal(classify(UA[bot], ip, table).verified, false, `${bot} ${ip}`);
  }
});

test("別の会社の範囲から来たら偽物になる（GPTBotを名乗ってAnthropicの範囲から）", () => {
  const [anthropicIp] = edges(raw.anthropic.prefixes[0]);
  assert.equal(classify(UA.GPTBot, anthropicIp, table).verified, false);
  const [gptIp] = edges(raw.gptbot.prefixes[0]);
  assert.equal(classify(UA.ClaudeBot, gptIp, table).verified, false);
});

test("範囲のすぐ外は偽物になる（gptbot.json の 20.125.66.80/28 の前後）", () => {
  assert.equal(ipInRanges("20.125.66.79", table.gptbot), false);
  assert.equal(ipInRanges("20.125.66.80", table.gptbot), true);
  assert.equal(ipInRanges("20.125.66.95", table.gptbot), true);
  assert.equal(ipInRanges("20.125.66.96", table.gptbot), false);
});

test("IPv4 を IPv6 の形（::ffff:）で書いても同じ結果になる", () => {
  const [ip] = edges(raw.gptbot.prefixes[0]);
  assert.equal(classify(UA.GPTBot, `::ffff:${ip}`, table).verified, true);
});

test("クローラーを名乗っていなければ null（記録しない）", () => {
  const chrome = "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1";
  assert.equal(classify(chrome, "203.0.113.45", table), null);
  assert.equal(classify("", "203.0.113.45", table), null);
});

test("壊れた入力でも例外を投げず、偽物として扱う", () => {
  for (const ip of ["", "999.1.1.1", "1.2.3", "2001:db8:::1", "hello", null, undefined]) {
    assert.equal(classify(UA.GPTBot, ip, table).verified, false, String(ip));
  }
});

✔ GPTBot: 公開範囲 18 件の先頭と末尾がすべて本物になる (1.3805ms)
✔ OAI-SearchBot: 公開範囲 39 件の先頭と末尾がすべて本物になる (0.813792ms)
✔ ChatGPT-User: 公開範囲 230 件の先頭と末尾がすべて本物になる (2.566583ms)
✔ ClaudeBot: 公開範囲 28 件の先頭と末尾がすべて本物になる (0.279791ms)
✔ PerplexityBot: 公開範囲 8 件の先頭と末尾がすべて本物になる (0.114166ms)
✔ Perplexity-User: 公開範囲 4 件の先頭と末尾がすべて本物になる (0.047208ms)
✔ Googlebot: 公開範囲 317 件の先頭と末尾がすべて本物になる (3.125875ms)
✔ 名乗りは本物でも、文書用のアドレスから来たら偽物になる (0.28775ms)
✔ 別の会社の範囲から来たら偽物になる（GPTBotを名乗ってAnthropicの範囲から） (0.244833ms)
✔ 範囲のすぐ外は偽物になる（gptbot.json の 20.125.66.80/28 の前後） (0.255834ms)
✔ IPv4 を IPv6 の形（::ffff:）で書いても同じ結果になる (0.099667ms)
✔ クローラーを名乗っていなければ null（記録しない） (0.038792ms)
✔ 壊れた入力でも例外を投げず、偽物として扱う (0.056375ms)
ℹ tests 13
ℹ suites 0
ℹ pass 13
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 67.993167

// いちばん時間のかかる形（Googlebot を名乗って範囲の外から来る＝317件をすべて見る）を10万回
import { readFile } from "node:fs/promises";
import { compileRanges, classify } from "./bot-verify.js";
const table = compileRanges(JSON.parse(await readFile(new URL("./bot-ranges.json", import.meta.url), "utf8")));
const ua = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
for (const ip of ["203.0.113.45", "2001:db8::1"]) {
  const N = 100_000, t0 = performance.now();
  for (let i = 0; i < N; i++) classify(ua, ip, table);
  const ms = performance.now() - t0;
  console.log(`${ip.padEnd(14)} 1回あたり ${((ms / N) * 1000).toFixed(1)} マイクロ秒`);
}

203.0.113.45   1回あたり 0.9 マイクロ秒
2001:db8::1    1回あたり 1.7 マイクロ秒

$ host 66.249.66.1
1.66.249.66.in-addr.arpa domain name pointer crawl-66-249-66-1.googlebot.com.
$ host crawl-66-249-66-1.googlebot.com
crawl-66-249-66-1.googlebot.com has address 66.249.66.1
$ host 203.0.113.45
Host 45.113.0.203.in-addr.arpa. not found: 3(NXDOMAIN)

// 手元の確認用：クローラーを名乗ったリクエストだけ、判定結果をログに出す（応答は変えない）
import { compileRanges, classify } from "./bot-verify.js";
import ranges from "./bot-ranges.json";

const table = compileRanges(ranges); // 起動時に1回だけ変換する

export async function onRequest({ request, next }) {
  const res = await next();
  try {
    const result = classify(request.headers.get("user-agent"), request.headers.get("cf-connecting-ip"), table);
    if (result) {
      console.log(JSON.stringify({ ...result, path: new URL(request.url).pathname, ip: request.headers.get("cf-connecting-ip") }));
    }
  } catch (_) {
    // 判定の失敗は応答に関係させない
  }
  return res;
}

npx wrangler pages dev public --port 8837 --compatibility-date 2026-10-01
# 別の端末から
G="Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot"
curl -s -o /dev/null -w "%{http_code}\n" -A "$G" localhost:8837/
curl -s -o /dev/null -w "%{http_code}\n" -A "$G" -H "CF-Connecting-IP: 20.171.206.10" localhost:8837/
curl -s -o /dev/null -w "%{http_code}\n" -A "Mozilla/5.0 (iPhone)" localhost:8837/

[wrangler:info] Ready on http://localhost:8837
[wrangler:info] GET / 200 OK (15ms)
{"bot":"GPTBot","verified":false,"path":"/","ip":"::1"}
[wrangler:info] GET / 200 OK (3ms)
{"bot":"GPTBot","verified":true,"path":"/","ip":"20.171.206.10"}
[wrangler:info] GET / 200 OK (2ms)
[wrangler:info] GET / 200 OK (2ms)