Ի՞նչ են իրականում ստանում AI-ի կրաուլերները ձեր կայքից. սկրիպտ 66 տողով

Հրապարակված է

Կարճ պատասխան

Հարցրեք ձեր էջը որպես զննիչ և որպես յուրաքանչյուր AI կրաուլեր, ապա համեմատեք պատասխանները։ Եթե միայն կրաուլերին են տալիս 403, 429 կամ challenge էջ, կամ 200 պատասխանը զննիչի էջից շատ փոքր է, ուրեմն firewall-ը մերժում է կրաուլերին, թեև robots.txt-ը թույլ է տալիս։ 66 տողանոց Node սկրիպտը դա ստուգում է յոթ կրաուլերի համար և կարդում է robots.txt-ը RFC 9309-ի կանոններով։

robots.txt-ը ասում է, թե ինչ կարող է կրաուլերը բեռնել։ Բայց այն ոչինչ չի ասում այն մասին, թե ձեր firewall-ը կամ CDN-ը իրականում ինչ է վերադարձնում։ Այս հոդվածում կգտնեք կարճ սկրիպտ, որը երկուսը ցույց է տալիս կողք կողքի, որպեսզի տեսնեք, թե որտեղ են դրանք իրար հակասում։

Այս էջում
  1. Ինչո՞ւ robots.txt-ը չի ասում, թե ինչ է ստանում կրաուլերը
  2. Սկրիպտը
  3. Ինչպե՞ս գործարկել
  4. Ինչպիսի՞ն է արդյունքը
  5. Ինչպե՞ս կարդալ աղյուսակը
  6. Ի՞նչ չի կարող ասել սկրիպտը
  7. Ի՞նչ ենք տեսնում իրական կայքերում

Ինչո՞ւ robots.txt-ը չի ասում, թե ինչ է ստանում կրաուլերը

robots.txt-ը խնդրանք է։ Թե ինչ կուղարկվի իրականում, որոշում է firewall-ը, CDN-ը կամ բոտերից պաշտպանության կանոնը։ Այն կարող է OAI-SearchBot-ին կամ PerplexityBot-ին պատասխանել 403-ով, 429-ով կամ «Just a moment...» էջով, մինչդեռ ձեր սեփական զննիչով այցերը բոլորովին նորմալ են երևում։

Ստուգումը պարզ է. նույն հասցեն հարցրեք որպես զննիչ և որպես կրաուլեր, ապա համեմատեք։ Միայն կրաուլերին տրված 403, 429 կամ 503, Just a moment... վերնագրով էջը կամ զննիչի էջից շատ փոքր 200 պատասխանը ցույց են տալիս, որ խնդիրը firewall-ում է։

Սկրիպտը

Պահպանեք այն ai-crawler-view.mjs անունով։ Պահանջում է Node 18 կամ ավելի նոր տարբերակ և ոչ մի փաթեթ։ Այն մեկ անգամ կարդում է robots.txt-ը, ապա ձեր էջը բեռնում է որպես զննիչ, հետո՝ որպես յոթ AI կրաուլեր՝ OAI-SearchBot, ChatGPT-User, GPTBot, Claude-SearchBot, ClaudeBot, PerplexityBot և 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-ը user agent-ների լրիվ տողեր չի հրապարակում, ուստի Claude-ի երկու տողերում օգտագործվում է միայն կրաուլերի թոքենը։ Թոքենով աշխատող firewall-ը նույն կերպ կարձագանքի։

Ինչպե՞ս գործարկել

Գործարկեք այն ձեր սեփական կայքի որևէ էջի վրա։ Ընտրովի --expect դրոշը ստուգում է՝ արդյոք ձեր հիմնական բովանդակությունից մի նախադասություն կա՞ յուրաքանչյուր կրաուլերի ստացած հում HTML-ում։ Եթե չկա, ուրեմն տեքստը սկրիպտերը ավելացնում են էջի բեռնումից հետո, և շատ կրաուլերներ այն չեն տեսնի։

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

Գործարկեք միայն այն կայքերի վրա, որոնք ձերն են կամ որոնք թեստավորելու թույլտվություն ունեք։ Այն ուղարկում է ինը հարցում՝ robots.txt-ի համար, զննիչի համար և մեկական՝ յուրաքանչյուր կրաուլերի համար։

Ինչպիսի՞ն է արդյունքը

Սա արդյունքն է դիտավորյալ թշնամական տեղային թեստային սերվերի դեմ, որը challenge է տալիս OAI-SearchBot-ին, սահմանափակում է ClaudeBot-ի հարցումների հաճախականությունը, PerplexityBot-ին տալիս է դատարկ կճեպ և robots.txt-ում արգելում է GPTBot-ը։

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

aiseewhy.com-ում յուրաքանչյուր կրաուլեր ստանում է ամբողջ էջը՝ նույն կարգավիճակով և նույն չափով, ինչ զննիչը։

Ինչպե՞ս կարդալ աղյուսակը

Ի՞նչ չի կարող ասել սկրիպտը

Ի՞նչ ենք տեսնում իրական կայքերում

AISeeWhy-ը նման ստուգում անում է 14 կրաուլերի համար։ ԱՄՆ-ի, Մեծ Բրիտանիայի և Ֆրանսիայի 165 բիզնես կայքերից, որոնք կարողացանք թեստավորել, 38%-ը (63 կայք) սերվերի մակարդակով մերժել է առնվազն մեկ AI կրաուլերի, մինչդեռ նույն հասցեից եկած զննիչը էջը ստացել է։ Այդ կայքերից յուրաքանչյուրը մերժել է առնվազն մեկ ուսուցման կամ սկրեյպերի բոտի, իսկ 10%-ը (16 կայք) մերժել է նաև առնվազն մեկ AI որոնման կրաուլերի, օրինակ՝ PerplexityBot-ի (11 կայք) կամ OAI-SearchBot-ի (5)։

Կայքերը պատահական ընտրանք չեն, և ևս 53-ը չկարողացանք թեստավորել, քանի որ նույնիսկ սովորական զննիչի հարցումը մերժվեց կամ անպատասխան մնաց։ Սա համարեք ձեր կայքում ստուգելու արժանի օրինաչափություն, այլ ոչ թե մարդահամար։

Անվճար գործիքներ

Հաջորդ քայլերը

Այս հոդվածում նշված ռոբոտները

Հաճախ տրվող հարցեր

Անվտանգ է արդյո՞ք սա գործարկել ցանկացած կայքի վրա

Գործարկեք միայն այն կայքերի վրա, որոնք ձերն են կամ որոնք թեստավորելու թույլտվություն ունեք։ Այն ուղարկում է կրաուլերների user agent-ներով հարցումներ, որոնց բոտերից պաշտպանության որոշ համակարգեր թշնամական են համարում։

Ինչո՞ւ GPTBot-ի մոտ ok է երևում, երբ robots.txt-ն այն արգելում է

robots.txt-ը խնդրանք է, այլ ոչ թե կղպանք։ Սերվերը պատասխանում է նրան, ով այն անտեսում է, ուստի HTTP սյունում ok է։ Կողքի կանոնը ցույց է տալիս, թե ինչին է հետևում բարեխիղճ կրաուլերը։

Սկրիպտը JavaScript կատարո՞ւմ է

Ոչ, դիտավորյալ։ Այն ցույց է տալիս այն HTML-ը, որ ստանում է էջերը չռենդերող կրաուլերը։ --expect դրոշը ասում է՝ ձեր հիմնական տեքստն արդեն այդ HTML-ում կա՞։

Մաքուր արդյունքը նշանակո՞ւմ է, որ ChatGPT-ն կմեջբերի իմ էջը

Ոչ։ Հասանելիությունը անհրաժեշտ է, բայց բավարար չէ։ Որպեսզի տեսնեք՝ օգնականը նշո՞ւմ է ձեր կայքը, տվեք նրան ձեր գնորդների տված հարցերը և նշեք, թե որ կայքերն է մեջբերում։

Աղբյուրներ

Այլ հոդվածներ