ఒక URL, ఒక నిర్దిష్ట క్రాలర్ కోసం robots.txt రూల్స్ను ఎలా పరీక్షించాలి?
ఒక క్రాలర్ కోసం URLను పరీక్షించడానికి, ఆ క్రాలర్ టోకెన్ పేరున్న గ్రూప్ను కనుగొనండి (అలాంటిది లేకపోతే User-agent: *), అందులో URL పాత్కు సరిపోలే ప్రతి Allow, Disallow రూల్ను సేకరించి, అత్యంత పొడవైనదాన్ని వర్తింపజేయండి; సమానమైతే Allow గెలుస్తుంది. దీన్ని చేతితో, Google ఓపెన్ సోర్స్ పార్సర్తో, లేదా ఒక్కో క్రాలర్కు ఫలితం చూపించే చెకర్తో చేయవచ్చు. Search Consoleలోని పాత robots.txt Tester ఇప్పుడు లేదు, దాని స్థానంలో వచ్చిన robots.txt రిపోర్ట్ Google ఏమి తెచ్చుకుందో చూపిస్తుంది, URLకు ఫలితం చూపించదు.
ఖచ్చితమైన జవాబు కావాల్సి వచ్చే వరకు robots.txt ఫైల్ సులభంగానే కనిపిస్తుంది: GPTBot ఈ పేజీని తెచ్చుకోవచ్చా, OAI-SearchBot తెచ్చుకోవచ్చా? జవాబు క్రాలర్ ఏ గ్రూప్ను ఎంచుకుంటుంది, ఆ గ్రూప్లో ఏ రూల్ గెలుస్తుంది అనే దానిపై ఆధారపడుతుంది, రెండు దశల్లోనూ పొరపాటు చేయడం సులభం. RFC 9309 ప్రకారం మ్యాచింగ్ ఎలా పనిచేస్తుంది, నాలుగు ఉదాహరణలు, ఫైల్ను మీరే పరీక్షించడానికి మూడు మార్గాలు ఇక్కడ ఉన్నాయి.
ఈ పేజీలో
- Google Search Consoleలోని robots.txt Tester ఏమైంది?
- URL అనుమతించబడిందో లేదో క్రాలర్ ఎలా నిర్ణయిస్తుంది?
- robots.txt పరీక్షకు ఒక ఉదాహరణ చూపించగలరా?
- Google ఓపెన్ సోర్స్ robots.txt పార్సర్ను ఎలా నడపాలి?
- Python urllib.robotparserతో robots.txtను పరీక్షించవచ్చా?
- robots.txt పరీక్ష పాస్ అయినా క్రాలర్ ఎందుకు బ్లాక్ అవుతోంది?
- అన్ని AI క్రాలర్ల కోసం robots.txtను ఒకేసారి ఎలా తనిఖీ చేయాలి?
Google Search Consoleలోని robots.txt Tester ఏమైంది?
నవంబర్ 2023లో Google Search Consoleకు robots.txt రిపోర్ట్ను జోడించి, robots.txt టెస్టర్ను నిలిపివేస్తున్నట్టు చెప్పింది. ఈ రిపోర్ట్ Settings కింద ఉంటుంది, Google క్రాలర్లను మాత్రమే కవర్ చేస్తుంది. ఇది చూపించేవి:
- మీ ప్రాపర్టీలోని టాప్ 20 హోస్ట్ల కోసం Google కనుగొన్న robots.txt ఫైల్లు.
- ప్రతి ఫైల్ fetch స్థితి (
Fetched,Not Fetched - Not found (404)లేదాNot Fetched - Any other reason), Google చివరిసారి ఎప్పుడు తనిఖీ చేసింది, బైట్లలో దాని పరిమాణం. - ఫైల్లోని సమస్యలు. ఎర్రర్లు రూల్ను ఉపయోగించకుండా ఆపుతాయని, హెచ్చరికలు ఆపవని Google చెబుతుంది.
- గత 30 రోజుల్లో Google తెచ్చుకున్న వెర్షన్లు, ఫైల్ సరిచేసిన తర్వాత మళ్లీ క్రాల్ చేయమని అభ్యర్థించే బటన్.
ఈ రిపోర్ట్ URL తీసుకుని అనుమతించబడిందా, బ్లాక్ అయిందా అని చెప్పదు. Googlebot కోసం ఒక URLను తనిఖీ చేయడానికి Google URL Inspection టూల్ను, స్థానిక పరీక్షకు తన ఓపెన్ సోర్స్ robots.txt లైబ్రరీని సూచిస్తుంది. GPTBot లేదా ClaudeBot వంటి AI క్రాలర్ల గురించి వీటిలో ఏదీ ఏమీ చెప్పదు.
URL అనుమతించబడిందో లేదో క్రాలర్ ఎలా నిర్ణయిస్తుంది?
మ్యాచింగ్ను Robots Exclusion Protocol అయిన RFC 9309 నిర్వచిస్తుంది. తన క్రాలర్ల కోసం Google కూడా ఇదే ప్రవర్తనను డాక్యుమెంట్ చేస్తుంది.
- గ్రూప్ను ఎంచుకోవడం. User-agent మ్యాచింగ్ కేస్ను పట్టించుకోదు. ఒకటి లేదా ఎక్కువ గ్రూప్లు క్రాలర్ టోకెన్ పేరు చెబితే, వాటి రూల్స్ కలుస్తాయి,
User-agent: *గ్రూప్ పూర్తిగా విస్మరించబడుతుంది. తన పేరున్న గ్రూప్ లేని క్రాలర్ మాత్రమే*ను అనుసరిస్తుంది. - రూల్ను ఎంచుకోవడం. URLకు సరిపోలే పాత్ ఉన్న
Allow,Disallowరూల్స్లో ఎక్కువ అక్షరాలు ఉన్నది గెలుస్తుంది.Allow,Disallowసమాన పొడవు ఉంటేAllowగెలవాలి. - ప్యాటర్న్లను చదవడం.
*ఎన్ని అక్షరాలకైనా సరిపోతుంది,$URL ముగింపును సూచిస్తుంది. పాత్లు కేస్-సెన్సిటివ్, కాబట్టి/Admin//admin/కు సరిపోదు. - సరిపోలే రూల్ లేకపోతే అనుమతి ఉన్నట్టే.
/robots.txtఎప్పుడూ అనుమతించబడుతుంది.
robots.txt రూల్స్ ఎంత ముఖ్యమో దాని రెస్పాన్స్ కోడ్ కూడా అంతే ముఖ్యం. 4xx రెస్పాన్స్ అంటే క్రాలర్ అన్నీ తెచ్చుకోవచ్చు; 429 తప్ప ప్రతి 4xxను Google ఫైల్ లేనట్టే పరిగణిస్తుంది. 5xx రెస్పాన్స్ అంటే మొత్తం సైట్ నిషేధించబడిందని క్రాలర్ భావించాలి. Google మొదటి 12 గంటలు క్రాలింగ్ ఆపి, తర్వాత 30 రోజుల వరకు చివరి సరైన కాపీని ఉపయోగిస్తుంది. క్రాలర్లు కనీసం 500 KiB పార్స్ చేయాలని RFC 9309 కోరుతుంది, 500 KiB తర్వాత ఉన్నదాన్ని Google విస్మరిస్తుంది.
robots.txt పరీక్షకు ఒక ఉదాహరణ చూపించగలరా?
డిఫాల్ట్ గ్రూప్, పేరున్న రెండు AI క్రాలర్లతో ఒక చిన్న robots.txt ఇది:
Googlebot,/search/help/billing: అనుమతించబడింది. Googlebot గ్రూప్ లేదు, కాబట్టి*గ్రూప్ వర్తిస్తుంది.Disallow: /search,Allow: /search/helpరెండూ సరిపోతాయి,Allowరూల్ పొడవైనది.GPTBot,/blog/post: బ్లాక్ అయింది. GPTBotకు సొంత గ్రూప్ ఉంది,Disallow: /ప్రతి పాత్కు సరిపోతుంది.OAI-SearchBot,/admin/settings: అనుమతించబడింది. OAI-SearchBotకు సొంత గ్రూప్ ఉంది, కాబట్టి*గ్రూప్లోనిDisallow: /admin/దానికి వర్తించదు. ఇదే అత్యంత సాధారణ ఆశ్చర్యం; ఉమ్మడి రూల్స్ను పేరున్న ప్రతి గ్రూప్లో మళ్లీ రాయండి.OAI-SearchBot,/files/report.pdf: బ్లాక్ అయింది.Allow: /ఒక అక్షరంతో సరిపోతుంది,Disallow: /*.pdf$ఏడు అక్షరాలతో సరిపోతుంది, పొడవైన రూల్ గెలుస్తుంది.
User-agent: *
Disallow: /admin/
Disallow: /search
Allow: /search/help
User-agent: GPTBot
Disallow: /
User-agent: OAI-SearchBot
Allow: /
Disallow: /drafts/
Disallow: /*.pdf$ సమానమైన సందర్భాలు అరుదు కానీ అదే తర్కాన్ని అనుసరిస్తాయి. URL /folder/page కోసం allow: /folder, disallow: /folder ఉదాహరణను Google డాక్యుమెంటేషన్ ఇస్తుంది: రెండూ ఒకే పొడవు, కాబట్టి URL అనుమతించబడుతుంది.
Google ఓపెన్ సోర్స్ robots.txt పార్సర్ను ఎలా నడపాలి?
robots.txt రూల్స్ను మ్యాచ్ చేయడానికి తాను ప్రొడక్షన్లో ఉపయోగించే C++ లైబ్రరీని Google ప్రచురిస్తుంది, స్థానిక ఫైల్కు ఎదురుగా ఒక URL, ఒక యూజర్ ఏజెంట్ను పరీక్షించడానికి చిన్న కమాండ్-లైన్ ప్రోగ్రామ్తో పాటు. Bazel ఇన్స్టాల్ చేసి ఉంటే:
git clone https://github.com/google/robotstxt.git robotstxt
cd robotstxt/
bazel build :robots_main
# arguments: local robots.txt file, crawler token, full URL
bazel run robots_main -- ~/robots.txt OAI-SearchBot https://example.com/files/report.pdf
# prints ALLOWED or DISALLOWED; exit code 0 means allowed, 1 means disallowed రిపోజిటరీ CMake బిల్డ్ను కూడా డాక్యుమెంట్ చేస్తుంది, అది అవే ఆర్గ్యుమెంట్లతో robots అనే బైనరీని తయారు చేస్తుంది. ఈ టూల్ పార్స్ చేసి మ్యాచ్ చేస్తుంది మాత్రమే; robots.txtను డౌన్లోడ్ చేయదు, కాబట్టి ముందు లైవ్ ఫైల్ను సేవ్ చేయండి. పార్సింగ్, మ్యాచింగ్ బయట ఉండే క్రాలర్-నిర్దిష్ట ప్రవర్తన లైబ్రరీలో భాగం కాదని దాని README కూడా చెబుతుంది.
Python urllib.robotparserతో robots.txtను పరీక్షించవచ్చా?
Python స్టాండర్డ్ లైబ్రరీలో ఒక యూజర్ ఏజెంట్, ఒక URL కోసం అనుమతించబడిందా, బ్లాక్ అయిందా అని చెప్పే పార్సర్ ఉంది. ఈ స్క్రిప్ట్ పై ఉదాహరణను పరీక్షిస్తుంది:
from urllib.robotparser import RobotFileParser
# Paste the robots.txt you want to test, or fetch it yourself first
ROBOTS_TXT = """
User-agent: *
Disallow: /admin/
Disallow: /search
Allow: /search/help
User-agent: GPTBot
Disallow: /
User-agent: OAI-SearchBot
Allow: /
Disallow: /drafts/
Disallow: /*.pdf$
"""
tests = [
("Googlebot", "https://example.com/search/help/billing"),
("GPTBot", "https://example.com/blog/post"),
("OAI-SearchBot", "https://example.com/admin/settings"),
("OAI-SearchBot", "https://example.com/files/report.pdf"),
]
rp = RobotFileParser()
rp.parse(ROBOTS_TXT.splitlines())
for agent, url in tests:
print(f"{agent:15} {url} ->", "allowed" if rp.can_fetch(agent, url) else "blocked") అవుట్పుట్ను నమ్మే ముందు మీ Python వెర్షన్ను తనిఖీ చేయండి. RFC 9309 మ్యాచింగ్ మద్దతు 2026లో CPythonకు జోడించబడింది, మొదట Python 3.13.14, 3.14.5లో వచ్చింది. 3.12, అంతకంటే పాత అన్ని వెర్షన్లతో సహా పాత రిలీజ్లు పొడవైన రూల్ను కాకుండా ఫైల్ క్రమంలో మొదట సరిపోలే రూల్ను వర్తింపజేస్తాయి, పాత్లలో *, $లను అర్థం చేసుకోవు. ఆ వెర్షన్లలో స్క్రిప్ట్ మొదటి, నాలుగో పరీక్షలను తారుమారుగా చూపిస్తుంది: Googlebot /search/help/billing నుంచి బ్లాక్ అయిందని, OAI-SearchBot PDFను తెచ్చుకోవచ్చని.
ప్రతి వెర్షన్కు మరో రెండు తేడాలు వర్తిస్తాయి. RobotFileParser.read() robots.txt కోసం 401 లేదా 403 రెస్పాన్స్ను అన్నీ నిషేధించినట్టుగా పరిగణిస్తుంది, కానీ 4xx అంటే అన్నీ తెచ్చుకోవచ్చని RFC 9309 చెబుతుంది. read() ఫైల్ను Python డిఫాల్ట్ యూజర్ ఏజెంట్తో డౌన్లోడ్ చేస్తుంది, కొన్ని ఫైర్వాల్లు దాన్ని బ్లాక్ చేస్తాయి, కాబట్టి మీ రూల్స్తో సంబంధం లేని కారణాల వల్ల పరీక్ష బ్లాక్ అయిందని చూపించవచ్చు. పైన చేసినట్టు ఫైల్ను మీరే తెచ్చుకుని parse()కు ఇస్తే రెండు సమస్యలూ తప్పుతాయి.
robots.txt పరీక్ష పాస్ అయినా క్రాలర్ ఎందుకు బ్లాక్ అవుతోంది?
టెస్టర్ ఒకే ప్రశ్నకు జవాబిస్తుంది: రూల్స్ ఈ URLను అనుమతిస్తాయా? ఆ జవాబు బయట చాలా విషయాలు ఉంటాయి:
- లైవ్ ఫైల్ మీరు పరీక్షించినదానికి భిన్నంగా ఉంది, లేదా క్రాలర్ ఇంకా కాష్ చేసిన కాపీని ఉపయోగిస్తోంది. క్రాలర్లు కాష్ కాపీని 24 గంటలకు మించి ఉపయోగించకూడదని RFC 9309 చెబుతుంది, Google సాధారణంగా 24 గంటల వరకు కాష్ చేస్తుంది.
- robots.txt URL HTML పేజీని లేదా ఎర్రర్ను ఇస్తుంది. స్టేటస్ 200తో వచ్చే HTML పేజీలో సరైన రూల్స్ ఉండవు, 5xx రెస్పాన్స్ మొత్తం సైట్ను బ్లాక్ చేస్తుంది.
- robots.txt ఒక అభ్యర్థన మాత్రమే, యాక్సెస్ నియంత్రణ కాదు. ఫైర్వాల్, CDN లేదా బాట్ ప్రొటెక్షన్ క్రాలర్కు 403 లేదా ఛాలెంజ్ పేజీతో జవాబివ్వవచ్చు.
అన్ని AI క్రాలర్ల కోసం robots.txtను ఒకేసారి ఎలా తనిఖీ చేయాలి?
ఉచిత AISeeWhy robots.txt చెకర్ పేజీ చిరునామాను లేదా అతికించిన robots.txtను తీసుకుని, ప్రతి AI, సెర్చ్ క్రాలర్ ఆ పేజీని తెచ్చుకోవచ్చో చూపిస్తుంది. ఉచిత robots.txt జనరేటర్ మీ ఎంపికల ఆధారంగా ఫైల్ రాస్తుంది, ఉచిత తనిఖీ పేజీని 16 క్రాలర్లుగా తెచ్చుకుని, robots.txt అనుమతించినదాన్ని ఫైర్వాల్ బ్లాక్ చేస్తుందో చూపిస్తుంది.
ఈ సమస్యకు పరిష్కారాలు
- robots.txt GPTBotను అనుమతిస్తోంది, కానీ సర్వర్ బ్లాక్ చేస్తోంది
- robots.txt OAI-SearchBotను నిషేధిస్తోంది
- robots.txt ఒక HTML పేజీ
- robots.txtను తెచ్చుకోలేకపోయాం
తదుపరి దశలు
- AI క్రాలర్ల కోసం robots.txt టెస్టర్, చెకర్
- పూర్తి రిపోర్ట్ ఉదాహరణను చూడండి
- AI క్రాలర్ మానిటరింగ్
- ప్లాన్లు, ధరలు
ఈ వ్యాసంలోని క్రాలర్లు
తరచుగా అడిగే ప్రశ్నలు
Google Search Consoleలో ఇంకా robots.txt టెస్టర్ ఉందా?
లేదు. నవంబర్ 2023లో Google దాని స్థానంలో robots.txt రిపోర్ట్ను తెచ్చింది, అది Google తెచ్చుకున్న ఫైల్లు, వాటి స్థితి, ఏవైనా ఎర్రర్లను చూపిస్తుంది. Googlebot ఒక నిర్దిష్ట URLను క్రాల్ చేయవచ్చో తనిఖీ చేయడానికి URL Inspection టూల్ ఉపయోగించండి.
robots.txtలో Allow, Disallowను అధిగమిస్తుందా?
Allow రూల్ పొడవైనదైతే, లేదా సరిగ్గా సమాన పొడవు ఉంటే మాత్రమే. రకం ఏదైనా, అత్యంత పొడవైన సరిపోలే పాత్ ఉన్న రూల్ గెలుస్తుంది, సమానమైతే Allow గెలుస్తుంది.
robots.txt కేస్-సెన్సిటివ్గా ఉంటుందా?
కొంతవరకు. User-agent విలువ కేస్ పట్టించుకోకుండా మ్యాచ్ అవుతుంది, కాబట్టి gptbot, GPTBot ఒకే గ్రూప్ను సూచిస్తాయి. పాత్లు కేస్-సెన్సిటివ్, కాబట్టి Disallow: /Private/ /private/ను బ్లాక్ చేయదు.
robots.txt వ్యాలిడేటర్ ఏమి తనిఖీ చేస్తుంది?
ఫైల్ అందుబాటులో ఉందా, టెక్స్ట్గా ఇవ్వబడుతుందా, సరైన సింటాక్స్లో రాయబడిందా అని వ్యాలిడేటర్ తనిఖీ చేస్తుంది. టెస్టర్ ఇంకా ముందుకెళ్లి ఒక నిర్దిష్ట URL, క్రాలర్ కోసం ఫలితం ఇస్తుంది. సాధారణంగా రెండూ కావాలి, ఎందుకంటే సరైన ఫైల్ కూడా మీరు అనుమతించాలనుకున్న పేజీని బ్లాక్ చేయవచ్చు.
క్రాలర్కు సొంత గ్రూప్ ఉంటే అది ఇంకా User-agent: *ను అనుసరిస్తుందా?
లేదు. పేరున్న గ్రూప్ ఆ క్రాలర్ కోసం * గ్రూప్ను పూర్తిగా భర్తీ చేస్తుంది. అందరికీ వర్తించాలనుకునే ప్రతి రూల్ను పేరున్న ప్రతి గ్రూప్లో మళ్లీ రాయాలి.
మూలాలు
- Google Search Console Help: robots.txt report
- Search Engine Roundtable: New Google Search Console robots.txt report replaced robots.txt tester tool
- Google Search Central: How Google interprets the robots.txt specification
- Google Search Central: Create and submit a robots.txt file
- RFC 9309: Robots Exclusion Protocol
- GitHub: google/robotstxt
- Python documentation: urllib.robotparser
- CPython source: Lib/urllib/robotparser.py