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 ಮತ್ತು ಬೈಟ್ ಕಾಲಮ್ಗಳು ಸರ್ವರ್ ಏನು ಮಾಡಿತು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತವೆ. robots.txt ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸುವ ಯಾರಿಗೂ ಸರ್ವರ್ ಉತ್ತರಿಸುವುದರಿಂದ
GPTBotಗೆ 200 ತೋರಿಸುತ್ತದೆ. ಪಕ್ಕದಲ್ಲಿರುವ ನಿಯಮವನ್ನೇ ಒಳ್ಳೆಯ ನಡತೆಯ ಕ್ರಾಲರ್ ಪಾಲಿಸುತ್ತದೆ. - ಅಪಾಯಕಾರಿ ಸಾಲುಗಳು ಇದಕ್ಕೆ ವಿರುದ್ಧವಾದವು:
allow: /ಪಕ್ಕದಲ್ಲಿBLOCKEDಅಥವಾTHIN. ಅಂದರೆ ಹೌದು ಎಂದು ಹೇಳಿ ಇಲ್ಲ ಎಂದು ಉತ್ತರಿಸುವ ಸೈಟ್.
ಸ್ಕ್ರಿಪ್ಟ್ ಏನನ್ನು ಹೇಳಲಾರದು?
- ಇದು ನಿಜವಾದ ಕ್ರಾಲರ್ಗಳನ್ನು ಅಲ್ಲ, ನಿಮ್ಮ ಸ್ವಂತ IP ವಿಳಾಸದಿಂದ user agent ಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಅನೇಕ ಫೈರ್ವಾಲ್ಗಳು ಕ್ರಾಲರ್ ಅನ್ನು ಅದರ ಒದಗಿಸುವವರು ಪ್ರಕಟಿಸಿದ IP ವ್ಯಾಪ್ತಿಗಳಿಂದ ಪರಿಶೀಲಿಸುತ್ತವೆ. ಆದ್ದರಿಂದ ನಿಮ್ಮ ವಿನಂತಿ ತಿರಸ್ಕೃತವಾದಾಗ ನಿಜವಾದ
OAI-SearchBotಗೆ ಪ್ರವೇಶ ಸಿಗಬಹುದು, ಅಥವಾ ಉಲ್ಟಾ ಆಗಬಹುದು. user agent ಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವ ನಿಯಮಗಳನ್ನು ಹುಡುಕಲು ಇದನ್ನು ಬಳಸಿ, ನಂತರ ಒದಗಿಸುವವರ ಪ್ರಕಟಿತ IP ಪಟ್ಟಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ. - ಇದು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ JavaScript ಅನ್ನು ಚಲಾಯಿಸುವುದಿಲ್ಲ: ಪುಟವನ್ನು ರೆಂಡರ್ ಮಾಡದ ಕ್ರಾಲರ್ಗೆ ಕಾಣುವ HTML ಅನ್ನು ಅದು ತೋರಿಸುತ್ತದೆ.
- ಸ್ವಚ್ಛ ಫಲಿತಾಂಶ ಶಿಫಾರಸು ಅಲ್ಲ. ಓದಲು ಸಾಧ್ಯವಾಗುವುದು ಮತ್ತು ಉಲ್ಲೇಖಿಸಲ್ಪಡುವುದು ಒಂದೇ ಅಲ್ಲ.
ನಿಜವಾದ ವೆಬ್ಸೈಟ್ಗಳಲ್ಲಿ ನಾವು ಏನು ನೋಡುತ್ತೇವೆ?
AISeeWhy 14 ಕ್ರಾಲರ್ಗಳಿಗೆ ಇಂತಹ ಪರಿಶೀಲನೆ ನಡೆಸುತ್ತದೆ. ಅಮೆರಿಕ, ಬ್ರಿಟನ್ ಮತ್ತು ಫ್ರಾನ್ಸ್ನ 165 ವ್ಯಾಪಾರ ವೆಬ್ಸೈಟ್ಗಳಲ್ಲಿ (ನಾವು ಪರೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಾದವು), 38% (63 ಸೈಟ್ಗಳು) ಕನಿಷ್ಠ ಒಂದು AI ಕ್ರಾಲರ್ ಅನ್ನು ಸರ್ವರ್ ಮಟ್ಟದಲ್ಲಿ ಹಿಂದಕ್ಕೆ ಕಳುಹಿಸಿದವು, ಆದರೆ ಅದೇ ವಿಳಾಸದ ಬ್ರೌಸರ್ಗೆ ಪುಟ ಸಿಕ್ಕಿತು. ಆ ಪ್ರತಿ ಸೈಟ್ ಕನಿಷ್ಠ ಒಂದು ತರಬೇತಿ ಅಥವಾ ಸ್ಕ್ರೇಪರ್ ಬಾಟ್ ಅನ್ನು ತಿರಸ್ಕರಿಸಿತು, ಮತ್ತು 10% (16 ಸೈಟ್ಗಳು) ಕನಿಷ್ಠ ಒಂದು AI ಹುಡುಕಾಟ ಕ್ರಾಲರ್ ಅನ್ನೂ ತಿರಸ್ಕರಿಸಿದವು, ಉದಾಹರಣೆಗೆ PerplexityBot (11 ಸೈಟ್ಗಳು) ಅಥವಾ OAI-SearchBot (5).
ಈ ಸೈಟ್ಗಳು ಯಾದೃಚ್ಛಿಕ ಮಾದರಿ ಅಲ್ಲ, ಮತ್ತು ಇನ್ನೂ 53 ಸೈಟ್ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಆಗಲಿಲ್ಲ, ಏಕೆಂದರೆ ಸಾಮಾನ್ಯ ಬ್ರೌಸರ್ ವಿನಂತಿಯನ್ನೇ ತಿರಸ್ಕರಿಸಲಾಯಿತು ಅಥವಾ ಉತ್ತರ ಬರಲಿಲ್ಲ. ಇದನ್ನು ಜನಗಣತಿ ಎಂದು ಭಾವಿಸದೆ, ನಿಮ್ಮ ಸ್ವಂತ ಸೈಟ್ನಲ್ಲಿ ಪರಿಶೀಲಿಸಲು ಯೋಗ್ಯವಾದ ಮಾದರಿ ಎಂದು ಪರಿಗಣಿಸಿ.
ಮುಂದಿನ ಹಂತಗಳು
- AI ಕ್ರಾಲರ್ಗಳಿಗೆ robots.txt ಪರೀಕ್ಷಕ ಮತ್ತು ಪರಿಶೀಲಕ
- AI ಕ್ರಾಲರ್ IP ಪರಿಶೀಲನೆ
- ಪೂರ್ಣ ವರದಿಯ ಒಂದು ಉದಾಹರಣೆ ನೋಡಿ
- AI ಕ್ರಾಲರ್ ಮೇಲ್ವಿಚಾರಣೆ
- ಪ್ಲಾನ್ಗಳು ಮತ್ತು ಬೆಲೆಗಳು
ಈ ಲೇಖನದಲ್ಲಿರುವ ಕ್ರಾಲರ್ಗಳು
ಪದೇ ಪದೇ ಕೇಳುವ ಪ್ರಶ್ನೆಗಳು
ಯಾವುದೇ ಸೈಟ್ ಮೇಲೆ ಇದನ್ನು ಚಲಾಯಿಸುವುದು ಸುರಕ್ಷಿತವೇ?
ನಿಮ್ಮದೇ ಅಥವಾ ಪರೀಕ್ಷಿಸಲು ಅನುಮತಿ ಇರುವ ಸೈಟ್ಗಳ ಮೇಲೆ ಮಾತ್ರ ಚಲಾಯಿಸಿ. ಇದು ಕ್ರಾಲರ್ user agent ಗಳೊಂದಿಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಕೆಲವು ಬಾಟ್ ರಕ್ಷಣೆಗಳು ಇವನ್ನು ಶತ್ರುತ್ವದ ಚಟುವಟಿಕೆ ಎಂದು ಪರಿಗಣಿಸುತ್ತವೆ.
robots.txt GPTBot ಅನ್ನು ನಿರಾಕರಿಸಿದರೂ ಅದಕ್ಕೆ ok ಏಕೆ ತೋರಿಸುತ್ತದೆ?
robots.txt ಒಂದು ವಿನಂತಿ, ಬೀಗ ಅಲ್ಲ. ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸುವ ಯಾರಿಗೂ ಸರ್ವರ್ ಉತ್ತರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ HTTP ಕಾಲಮ್ ok ಎಂದು ಹೇಳುತ್ತದೆ. ಪಕ್ಕದಲ್ಲಿರುವ ನಿಯಮ ಒಳ್ಳೆಯ ನಡತೆಯ ಕ್ರಾಲರ್ ಏನನ್ನು ಪಾಲಿಸುತ್ತದೆ ಎಂದು ತೋರಿಸುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್ JavaScript ಅನ್ನು ಚಲಾಯಿಸುತ್ತದೆಯೇ?
ಇಲ್ಲ, ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ. ಪುಟಗಳನ್ನು ರೆಂಡರ್ ಮಾಡದ ಕ್ರಾಲರ್ಗೆ ಸಿಗುವ HTML ಅನ್ನು ಅದು ತೋರಿಸುತ್ತದೆ. ನಿಮ್ಮ ಮುಖ್ಯ ಪಠ್ಯ ಈಗಾಗಲೇ ಆ HTML ನಲ್ಲಿ ಇದೆಯೇ ಎಂದು --expect ಫ್ಲ್ಯಾಗ್ ಹೇಳುತ್ತದೆ.
ಸ್ವಚ್ಛ ಫಲಿತಾಂಶ ಎಂದರೆ 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)