რას იღებენ AI კრაულერები რეალურად თქვენი საიტიდან? 66-ხაზიანი სკრიპტი
მოითხოვეთ გვერდი ბრაუზერის სახელით და თითოეული AI კრაულერის სახელით, შემდეგ შეადარეთ. თუ მხოლოდ კრაულერს ეძლევა 403, 429 ან გამოწვევის გვერდი, ან 200 პასუხი ბევრად პატარაა, ვიდრე ბრაუზერის გვერდი, ფაირვოლი მას უარს ეუბნება მაშინაც, როცა robots.txt უშვებს. 66-ხაზიანი Node სკრიპტი ამას შვიდი კრაულერისთვის აკეთებს და robots.txt-ს RFC 9309-ის წესებით კითხულობს.
robots.txt კრაულერს ეუბნება, რის ჩამოტვირთვა შეუძლია. ის არაფერს ამბობს იმაზე, რას აბრუნებს რეალურად თქვენი ფაირვოლი ან CDN. ეს პოსტი გაძლევთ მოკლე სკრიპტს, რომელიც ორივეს გვერდიგვერდ აჩვენებს, რომ ნახოთ, სად არ ემთხვევა ისინი ერთმანეთს.
ამ გვერდზე
რატომ არ გვეუბნება robots.txt, რას იღებს კრაულერი?
robots.txt მხოლოდ თხოვნაა. რეალურად რას დააბრუნებს, ამას ფაირვოლი, CDN ან ბოტებისგან დაცვის წესი წყვეტს. მას შეუძლია OAI-SearchBot-ს ან PerplexityBot-ს უპასუხოს 403-ით, 429-ით ან "Just a moment..." გვერდით, მაშინ როცა თქვენი ბრაუზერიდან ყველაფერი სრულიად ნორმალურად გამოიყურება.
შემოწმების გზა ასეთია: მოითხოვეთ ერთი და იგივე URL ბრაუზერის და კრაულერის სახელით და შეადარეთ. 403, 429 ან 503 მხოლოდ კრაულერისთვის, გვერდი სათაურით Just a moment... ან 200 პასუხი, რომელიც ბრაუზერისაზე ბევრად პატარაა, ყველაფერი ფაირვოლზე მიუთითებს.
სკრიპტი
შეინახეთ როგორც 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-ის ორი ხაზი მხოლოდ კრაულერის ტოკენს იყენებს. ფაირვოლი, რომელიც ტოკენით ამოიცნობს, ერთნაირად რეაგირებს.
როგორ გავუშვა?
გაუშვით თქვენი საიტის რომელიმე გვერდზე. არასავალდებულო ფლაგი --expect ამოწმებს, არის თუ არა თქვენი ძირითადი კონტენტის ერთი წინადადება იმ ნედლ HTML-ში, რომელსაც თითოეული კრაულერი იღებს. თუ არ არის, ტექსტს სკრიპტები ამატებენ ჩატვირთვის შემდეგ და ბევრი კრაულერი მას ვერ ნახავს.
node ai-crawler-view.mjs https://your-site.com/pricing/ --expect "a sentence from your page" გაუშვით მხოლოდ თქვენს საიტებზე ან იქ, სადაც ტესტირების უფლება გაქვთ. ის აგზავნის ცხრა მოთხოვნას: robots.txt, ბრაუზერი და თითო თითოეული კრაულერისთვის.
როგორ გამოიყურება შედეგი?
ეს არის შედეგი განზრახ მტრულ ლოკალურ სატესტო სერვერზე, რომელიც 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 მისამართიდან და არა რეალური კრაულერებისგან. ბევრი ფაირვოლი კრაულერს ამოწმებს იმ 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-ის ტესტერი და შემმოწმებელი AI კრაულერებისთვის
- AI კრაულერების IP შემოწმება
- ნახეთ სრული რეპორტის მაგალითი
- AI კრაულერების მონიტორინგი
- გეგმები და ფასები
ამ სტატიაში ნახსენები კრაულერები
ხშირად დასმული კითხვები
უსაფრთხოა ამის გაშვება ნებისმიერ საიტზე?
გაუშვით მხოლოდ თქვენს საიტებზე ან იქ, სადაც ტესტირების უფლება გაქვთ. ის აგზავნის მოთხოვნებს კრაულერების user agent-ებით, რასაც ბოტებისგან დაცვის ზოგიერთი სისტემა მტრულად აღიქვამს.
რატომ აჩვენებს GPTBot-ი ok-ს, როცა robots.txt კრძალავს?
robots.txt თხოვნაა და არა საკეტი. სერვერი პასუხობს ყველას, ვინც მას უგულებელყოფს, ამიტომ HTTP სვეტში ok წერია. გვერდით მდებარე წესი აჩვენებს, რასაც კეთილსინდისიერი კრაულერი ემორჩილება.
ასრულებს თუ არა სკრიპტი JavaScript-ს?
არა, განზრახ. ის აჩვენებს HTML-ს, რომელსაც იღებს კრაულერი, რომელიც გვერდებს არ რენდერავს. ფლაგი --expect გეტყვით, არის თუ არა თქვენი ძირითადი ტექსტი უკვე ამ HTML-ში.
ნიშნავს თუ არა სუფთა შედეგი, რომ ChatGPT ჩემს გვერდს მოიხსენიებს?
არა. წვდომა აუცილებელია, მაგრამ საკმარისი არ არის. რომ ნახოთ, ასახელებს თუ არა ასისტენტი თქვენს საიტს, დაუსვით კითხვები, რომლებსაც თქვენი მყიდველები სვამენ, და დააფიქსირეთ, რომელ საიტებს ციტირებს.
წყაროები
- RFC 9309: რობოტების გამორიცხვის პროტოკოლი
- OpenAI: OpenAI-ის კრაულერების მიმოხილვა
- Anthropic: აგროვებს თუ არა Anthropic მონაცემებს ვებიდან და როგორ შეუძლიათ საიტის მფლობელებს კრაულერის დაბლოკვა?
- Perplexity: Perplexity-ის კრაულერები
- Cloudflare: AI კრაულერების მართვა (AI Crawl Control)