ഒരു URL-നും ഒരു പ്രത്യേക ക്രോളറിനും robots.txt നിയമങ്ങൾ എങ്ങനെ ടെസ്റ്റ് ചെയ്യാം?
ഒരു ക്രോളറിനായി ഒരു URL ടെസ്റ്റ് ചെയ്യാൻ, ക്രോളറിന്റെ ടോക്കൺ പേരെടുത്ത് പറയുന്ന ഗ്രൂപ്പ് കണ്ടെത്തുക (ഒന്നുമില്ലെങ്കിൽ User-agent: *), അതിൽ URL പാത്തുമായി ചേരുന്ന എല്ലാ Allow, Disallow നിയമങ്ങളും എടുക്കുക, ഏറ്റവും നീളമുള്ളത് ബാധകമാക്കുക; നീളം തുല്യമാണെങ്കിൽ Allow ജയിക്കും. ഇത് നേരിട്ടോ Google-ന്റെ ഓപ്പൺ സോഴ്സ് പാർസർ ഉപയോഗിച്ചോ ഓരോ ക്രോളറിനും വിധി കാണിക്കുന്ന ഒരു ചെക്കർ ഉപയോഗിച്ചോ ചെയ്യാം. Search Console-ലെ Google-ന്റെ പഴയ 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 ഫയലുകൾ.
- ഓരോ ഫയലിന്റെയും ഫെച്ച് സ്റ്റാറ്റസ് (
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$ തുല്യനിലകൾ കുറവാണ്, പക്ഷേ അതേ യുക്തി പിന്തുടരുന്നു. /folder/page എന്ന URL-ന് 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 ടെസ്റ്റ് ചെയ്യാമോ?
ഒരു യൂസർ ഏജന്റിനും URL-നും അനുവദിച്ചു അല്ലെങ്കിൽ തടഞ്ഞു എന്ന് മറുപടി നൽകുന്ന ഒരു പാർസർ Python-ന്റെ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിലുണ്ട്. ഈ സ്ക്രിപ്റ്റ് മുകളിലെ ഉദാഹരണം ടെസ്റ്റ് ചെയ്യുന്നു:
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 എടുക്കാൻ അനുമതി.
എല്ലാ പതിപ്പിനും ബാധകമായ രണ്ട് വ്യത്യാസങ്ങൾ കൂടിയുണ്ട്. robots.txt-ന് 401 അല്ലെങ്കിൽ 403 റെസ്പോൺസ് വന്നാൽ RobotFileParser.read() എല്ലാം വിലക്കിയതായി കണക്കാക്കുന്നു, എന്നാൽ 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 ജനറേറ്റർ നിങ്ങളുടെ തിരഞ്ഞെടുപ്പുകളിൽ നിന്ന് ഫയൽ എഴുതുന്നു, robots.txt അനുവദിക്കുന്നത് ഒരു ഫയർവാൾ തടയുന്നുണ്ടോ എന്ന് കാണിക്കാൻ സൗജന്യ പരിശോധന 16 ക്രോളറുകളായി പേജ് എടുക്കുന്നു.
ഈ പ്രശ്നത്തിനുള്ള പരിഹാരങ്ങൾ
- 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 എടുത്ത ഫയലുകളും അവയുടെ സ്റ്റാറ്റസും പിശകുകളും കാണിക്കുന്നു. ഒരു പ്രത്യേക URL Googlebot-ന് ക്രോൾ ചെയ്യാമോ എന്ന് പരിശോധിക്കാൻ 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