Ի՞նչ են իրականում ստանում AI-ի կրաուլերները ձեր կայքից. սկրիպտ 66 տողով
Հարցրեք ձեր էջը որպես զննիչ և որպես յուրաքանչյուր AI կրաուլեր, ապա համեմատեք պատասխանները։ Եթե միայն կրաուլերին են տալիս 403, 429 կամ challenge էջ, կամ 200 պատասխանը զննիչի էջից շատ փոքր է, ուրեմն firewall-ը մերժում է կրաուլերին, թեև robots.txt-ը թույլ է տալիս։ 66 տողանոց Node սկրիպտը դա ստուգում է յոթ կրաուլերի համար և կարդում է robots.txt-ը RFC 9309-ի կանոններով։
robots.txt-ը ասում է, թե ինչ կարող է կրաուլերը բեռնել։ Բայց այն ոչինչ չի ասում այն մասին, թե ձեր firewall-ը կամ CDN-ը իրականում ինչ է վերադարձնում։ Այս հոդվածում կգտնեք կարճ սկրիպտ, որը երկուսը ցույց է տալիս կողք կողքի, որպեսզի տեսնեք, թե որտեղ են դրանք իրար հակասում։
Այս էջում
Ինչո՞ւ 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-ում յուրաքանչյուր կրաուլեր ստանում է ամբողջ էջը՝ նույն կարգավիճակով և նույն չափով, ինչ զննիչը։
Ինչպե՞ս կարդալ աղյուսակը
- robots.txt սյունը ձեր տված թույլտվությունն է. այն կանոնը, որ տվյալ կրաուլերի նկատմամբ կիրառվում է RFC 9309-ի համաձայն։ Դա կրաուլերին անվանող խումբն է, հակառակ դեպքում՝
*-ը, ապա ամենաերկար համընկնող կանոնը, իսկ հավասարության դեպքում հաղթում էAllow-ը։ - HTTP և bytes սյուները ցույց են տալիս, թե ինչ արեց սերվերը։
GPTBot-ի համար երևում է 200, քանի որ սերվերը պատասխանում է նրան, ով անտեսում է robots.txt-ը. կողքի կանոնը այն է, որին հետևում է բարեխիղճ կրաուլերը։ - Վտանգավոր են հակառակ տողերը՝
allow: /կողքինBLOCKEDկամTHIN։ Դա այն կայքն է, որ «այո» է ասում, բայց «ոչ» է պատասխանում։
Ի՞նչ չի կարող ասել սկրիպտը
- Այն թեստավորում է user agent-ները ձեր սեփական IP հասցեից, այլ ոչ թե իրական կրաուլերներից։ Շատ firewall-եր կրաուլերը ստուգում են վաճառողի հրապարակած IP միջակայքերով, ուստի իրական
OAI-SearchBot-ը կարող է անցնել, երբ ձեր հարցումը մերժվում է, կամ հակառակը։ Օգտագործեք այն user agent-ին արձագանքող կանոններ գտնելու համար, ապա ստուգեք վաճառողների հրապարակած IP ցուցակները։ - Այն դիտավորյալ չի կատարում JavaScript. ցույց է տալիս այն HTML-ը, որը կտեսնի չռենդերող կրաուլերը։
- Մաքուր արդյունքը երաշխիք չէ։ Կարդալի լինելը նույնը չէ, ինչ մեջբերվելը։
Ի՞նչ ենք տեսնում իրական կայքերում
AISeeWhy-ը նման ստուգում անում է 14 կրաուլերի համար։ ԱՄՆ-ի, Մեծ Բրիտանիայի և Ֆրանսիայի 165 բիզնես կայքերից, որոնք կարողացանք թեստավորել, 38%-ը (63 կայք) սերվերի մակարդակով մերժել է առնվազն մեկ AI կրաուլերի, մինչդեռ նույն հասցեից եկած զննիչը էջը ստացել է։ Այդ կայքերից յուրաքանչյուրը մերժել է առնվազն մեկ ուսուցման կամ սկրեյպերի բոտի, իսկ 10%-ը (16 կայք) մերժել է նաև առնվազն մեկ AI որոնման կրաուլերի, օրինակ՝ PerplexityBot-ի (11 կայք) կամ OAI-SearchBot-ի (5)։
Կայքերը պատահական ընտրանք չեն, և ևս 53-ը չկարողացանք թեստավորել, քանի որ նույնիսկ սովորական զննիչի հարցումը մերժվեց կամ անպատասխան մնաց։ Սա համարեք ձեր կայքում ստուգելու արժանի օրինաչափություն, այլ ոչ թե մարդահամար։
Հաջորդ քայլերը
- robots.txt-ի ստուգիչ (tester) AI ռոբոտների համար
- AI ռոբոտների IP ստուգում
- Տեսեք ամբողջական հաշվետվության օրինակ
- AI ռոբոտների մոնիթորինգ
- Պլաններ և գներ
Այս հոդվածում նշված ռոբոտները
Հաճախ տրվող հարցեր
Անվտանգ է արդյո՞ք սա գործարկել ցանկացած կայքի վրա
Գործարկեք միայն այն կայքերի վրա, որոնք ձերն են կամ որոնք թեստավորելու թույլտվություն ունեք։ Այն ուղարկում է կրաուլերների user agent-ներով հարցումներ, որոնց բոտերից պաշտպանության որոշ համակարգեր թշնամական են համարում։
Ինչո՞ւ GPTBot-ի մոտ ok է երևում, երբ robots.txt-ն այն արգելում է
robots.txt-ը խնդրանք է, այլ ոչ թե կղպանք։ Սերվերը պատասխանում է նրան, ով այն անտեսում է, ուստի HTTP սյունում ok է։ Կողքի կանոնը ցույց է տալիս, թե ինչին է հետևում բարեխիղճ կրաուլերը։
Սկրիպտը JavaScript կատարո՞ւմ է
Ոչ, դիտավորյալ։ Այն ցույց է տալիս այն HTML-ը, որ ստանում է էջերը չռենդերող կրաուլերը։ --expect դրոշը ասում է՝ ձեր հիմնական տեքստն արդեն այդ HTML-ում կա՞։
Մաքուր արդյունքը նշանակո՞ւմ է, որ ChatGPT-ն կմեջբերի իմ էջը
Ոչ։ Հասանելիությունը անհրաժեշտ է, բայց բավարար չէ։ Որպեսզի տեսնեք՝ օգնականը նշո՞ւմ է ձեր կայքը, տվեք նրան ձեր գնորդների տված հարցերը և նշեք, թե որ կայքերն է մեջբերում։
Աղբյուրներ
- RFC 9309: Robots Exclusion Protocol
- OpenAI: Overview of OpenAI crawlers
- Anthropic: Does Anthropic crawl data from the web, and how can site owners block the crawler?
- Perplexity: Perplexity crawlers
- Cloudflare: Manage AI crawlers (AI Crawl Control)