Ce primesc de fapt crawlerele AI de pe site-ul tău? Un script de 66 de linii

Publicat

Răspuns scurt

Cere pagina ca un browser și ca fiecare crawler AI, apoi compară rezultatele. Un 403, un 429 sau o pagină de verificare doar pentru crawler, ori un 200 mult mai mic decât pagina din browser, arată că firewall-ul îl refuză chiar dacă robots.txt îl permite. Un script Node de 66 de linii face asta pentru șapte crawlere și citește robots.txt după regulile RFC 9309.

robots.txt spune unui crawler ce are voie să ceară. Nu spune nimic despre ce trimite de fapt firewall-ul sau CDN-ul tău. Acest articol îți dă un script scurt care arată ambele lucruri alăturat, ca să vezi unde nu se potrivesc.

Pe această pagină
  1. De ce robots.txt nu îți spune ce primește un crawler?
  2. Scriptul
  3. Cum îl rulez?
  4. Cum arată rezultatul?
  5. Cum citesc tabelul?
  6. Ce nu îți poate spune scriptul?
  7. Ce vedem pe site-uri reale?

De ce robots.txt nu îți spune ce primește un crawler?

robots.txt este o rugăminte. Un firewall, un CDN sau o regulă de protecție împotriva boturilor hotărăște ce se trimite cu adevărat și poate răspunde cu un 403, un 429 sau o pagină „Just a moment...” către OAI-SearchBot sau PerplexityBot, în timp ce vizitele tale din browser par complet normale.

Verificarea constă în a cere același URL ca un browser și ca crawlerul, apoi a compara. Un 403, 429 sau 503 doar pentru crawler, o pagină cu titlul Just a moment... sau un răspuns 200 mult mai mic decât cel din browser indică toate firewall-ul.

Scriptul

Salvează-l ca ai-crawler-view.mjs. Are nevoie de Node 18 sau mai nou și de niciun pachet. Citește robots.txt o dată, cere pagina ca un browser, apoi ca șapte crawlere AI: OAI-SearchBot, ChatGPT-User, GPTBot, Claude-SearchBot, ClaudeBot, PerplexityBot și Perplexity-User.

#!/usr/bin/env node
// ai-crawler-view: what do AI crawlers get from YOUR site, compared with a browser?
// Usage: node ai-crawler-view.mjs https://your-site.com/page [--expect "a sentence from your page"]
// Node 18+, no dependencies. Run it against sites you own: it sends requests with crawler user agents.
const BROWSER = "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";
const BOTS = [ // [robots.txt token, user agent]; Anthropic prints no full strings, so Claude gets a token-based one
  ["OAI-SearchBot", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot"],
  ["ChatGPT-User", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot"],
  ["GPTBot", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.1; +https://openai.com/gptbot"],
  ["Claude-SearchBot", "Mozilla/5.0 (compatible; Claude-SearchBot/1.0)"],
  ["ClaudeBot", "Mozilla/5.0 (compatible; ClaudeBot/1.0)"],
  ["PerplexityBot", "Mozilla/5.0 (compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)"],
  ["Perplexity-User", "Mozilla/5.0 (compatible; Perplexity-User/1.0; +https://perplexity.ai/perplexity-user)"],
];
const BLOCK = new Set([401, 403, 406, 429, 451, 503, 999]);
const CHALLENGE = /Just a moment\.\.\.|Attention Required! \| Cloudflare|\/cdn-cgi\/challenge-platform|_Incapsula_Resource|Access Denied/i;

const [url, ...rest] = process.argv.slice(2);
const expect = rest.includes("--expect") ? rest[rest.indexOf("--expect") + 1] : "";
if (!url) { console.error("usage: node ai-crawler-view.mjs https://site/page [--expect \"text\"]"); process.exit(2); }

async function get(u, ua) {
  try {
    const r = await fetch(u, { headers: { "user-agent": ua }, redirect: "follow", signal: AbortSignal.timeout(15000) });
    return { status: r.status, body: (await r.text()).slice(0, 500000) };
  } catch (e) { return { status: 0, body: "", error: e.cause?.code || e.name }; }
}

// robots.txt, RFC 9309 in short: the group naming the token wins, else "*"; longest match wins; Allow wins a tie.
function robotsVerdict(txt, token, path) {
  const groups = []; let cur = null;
  for (const raw of txt.split(/\r?\n/)) {
    const m = raw.replace(/#.*/, "").match(/^\s*([A-Za-z-]+)\s*:\s*(.*?)\s*$/); if (!m) continue;
    const [k, v] = [m[1].toLowerCase(), m[2]];
    if (k === "user-agent") { if (!cur || cur.rules.length) groups.push(cur = { agents: [], rules: [] }); cur.agents.push(v.toLowerCase()); }
    else if (cur && (k === "allow" || k === "disallow") && v) cur.rules.push([k, v]);
  }
  const g = groups.find(x => x.agents.includes(token.toLowerCase())) || groups.find(x => x.agents.includes("*"));
  if (!g) return "no rule";
  let best = null;
  for (const [k, p] of g.rules) {
    const re = new RegExp("^" + p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\\\$$/, "$"));
    if (re.test(path) && (!best || p.length > best[1].length || (p.length === best[1].length && k === "allow"))) best = [k, p];
  }
  return best ? `${best[0]}: ${best[1]}` : "no rule";
}

const target = new URL(url);
const robots = await get(new URL("/robots.txt", target).href, BROWSER);
const robotsOk = robots.status >= 200 && robots.status < 300 && !/<html/i.test(robots.body);
const control = await get(url, BROWSER);
const cLen = control.body.length;
console.log(`control (browser): HTTP ${control.status}, ${cLen} bytes${expect ? `, expected text ${control.body.includes(expect) ? "found" : "MISSING"}` : ""}`);
if (control.status === 0 || BLOCK.has(control.status)) console.log("  the browser request itself failed or was refused: results below are not meaningful");
console.log(`robots.txt: ${robots.status >= 500 ? "server error (RFC 9309: crawlers must assume everything is disallowed)" : robotsOk ? "read" : "none or not valid"}\n`);
console.log("crawler           robots.txt          HTTP  bytes   verdict");
for (const [token, ua] of BOTS) {
  const r = await get(url, ua);
  const rule = robotsOk ? robotsVerdict(robots.body, token, target.pathname + target.search) : "no rule";
  const challenge = CHALLENGE.test(r.body.slice(0, 20000)) && r.body.length < 20000;
  const verdict = BLOCK.has(r.status) || challenge ? "BLOCKED by the server"
    : r.status >= 400 || r.status === 0 ? `error ${r.status || r.error}`
    : r.body.length < cLen * 0.5 ? "THIN: much smaller than the browser's page"
    : expect && !r.body.includes(expect) ? "text MISSING from the HTML" : "ok";
  console.log(`${token.padEnd(17)} ${rule.padEnd(19)} ${String(r.status).padEnd(5)} ${String(r.body.length).padEnd(7)} ${verdict}${rule.startsWith("disallow") ? "  (robots.txt asks it to stay away)" : ""}`);
}

Anthropic nu publică șirurile complete de user agent, așa că cele două linii pentru Claude folosesc doar tokenul crawlerului. Un firewall care se potrivește după token reacționează la fel.

Cum îl rulez?

Rulează-l pe o pagină a propriului site. Opțiunea --expect este facultativă și verifică dacă o propoziție din conținutul principal apare în HTML-ul brut primit de fiecare crawler. Dacă lipsește, textul este adăugat de scripturi după încărcare, iar multe crawlere nu îl vor vedea.

node ai-crawler-view.mjs https://your-site.com/pricing/ --expect "a sentence from your page"

Rulează-l doar pe site-uri ale tale sau pe care ai voie să le testezi. Trimite nouă cereri: robots.txt, browserul și câte una pentru fiecare crawler.

Cum arată rezultatul?

Acesta este rezultatul pe un server local de test, ostil în mod intenționat, care provoacă OAI-SearchBot cu o verificare, limitează ritmul pentru ClaudeBot, servește lui PerplexityBot un schelet gol și interzice GPTBot în robots.txt:

control (browser): HTTP 200, 2618 bytes, expected text found
robots.txt: read

crawler           robots.txt          HTTP  bytes   verdict
OAI-SearchBot     allow: /            403   31      BLOCKED by the server
ChatGPT-User      allow: /            200   2618    ok
GPTBot            disallow: /         200   2618    ok  (robots.txt asks it to stay away)
Claude-SearchBot  allow: /            200   2618    ok
ClaudeBot         allow: /            429   9       BLOCKED by the server
PerplexityBot     allow: /            200   36      THIN: much smaller than the browser's page
Perplexity-User   allow: /            200   2618    ok

Pe aiseewhy.com fiecare crawler primește pagina completă, cu aceeași stare și aceeași dimensiune ca browserul.

Cum citesc tabelul?

Ce nu îți poate spune scriptul?

Ce vedem pe site-uri reale?

AISeeWhy face acest tip de verificare pentru 14 crawlere. Din 165 de site-uri de afaceri din SUA, Marea Britanie și Franța pe care le-am putut testa, 38% (63 de site-uri) au refuzat la nivel de server cel puțin un crawler AI, deși un browser de la aceeași adresă a primit pagina. Fiecare dintre aceste site-uri a refuzat cel puțin un bot de antrenare sau de scraping, iar 10% (16 site-uri) au refuzat și cel puțin un crawler AI de căutare, precum PerplexityBot (11 site-uri) sau OAI-SearchBot (5).

Site-urile nu formează un eșantion aleatoriu, iar alte 53 nu au putut fi testate pentru că până și o cerere simplă din browser a fost refuzată sau a rămas fără răspuns. Consideră-l un tipar care merită verificat pe site-ul tău, nu un recensământ.

Instrumente gratuite

Pașii următori

Crawlere din acest articol

Întrebări frecvente

Este sigur să rulez asta pe orice site?

Rulează-l doar pe site-uri ale tale sau pe care ai voie să le testezi. Trimite cereri cu user agent-uri de crawler, pe care unele sisteme de apărare împotriva boturilor le tratează ca ostile.

De ce arată GPTBot ok când robots.txt îl interzice?

robots.txt este o rugăminte, nu o încuietoare. Serverul răspunde oricui îl ignoră, de aceea coloana HTTP arată ok. Regula de lângă ea arată ce respectă un crawler care se poartă corect.

Rulează scriptul JavaScript?

Nu, intenționat. Arată HTML-ul primit de un crawler care nu randează paginile. Opțiunea --expect îți spune dacă textul tău principal se află deja în acel HTML.

Un rezultat curat înseamnă că ChatGPT îmi va cita pagina?

Nu. Accesul este necesar, dar nu suficient. Ca să vezi dacă un asistent îți numește site-ul, pune-i întrebările pe care le pun cumpărătorii tăi și notează ce site-uri citează.

Surse

Alte articole