કોઈ URL અને ચોક્કસ ક્રૉલર માટે robots.txt નિયમો કેવી રીતે ચકાસવા?
એક ક્રૉલર માટે URL ચકાસવા, ક્રૉલરના token નું નામ આપતો group શોધો (કોઈ ન હોય તો User-agent: *), તેમાંથી URL પાથ સાથે મેળ ખાતા બધા Allow અને Disallow નિયમો ભેગા કરો, અને સૌથી લાંબો નિયમ લાગુ કરો; લંબાઈ સરખી હોય તો Allow જીતે છે. તમે આ હાથે, Googleના open-source parserથી, કે દરેક ક્રૉલર માટે નિર્ણય બતાવતા ચેકરથી કરી શકો છો. Search Consoleનું જૂનું robots.txt Tester હવે નથી, અને તેની જગ્યા લેનાર robots.txt રિપોર્ટ બતાવે છે કે Googleએ શું મેળવ્યું, કોઈ URL માટેનો નિર્ણય નહીં.
robots.txt ફાઇલ સાદી લાગે છે, જ્યાં સુધી તમને ચોક્કસ જવાબની જરૂર ન પડે: શું GPTBot આ પેજ મેળવી શકે, અને શું OAI-SearchBot? જવાબ એના પર આધાર રાખે છે કે ક્રૉલર કયો group પસંદ કરે છે અને એ groupમાં કયો નિયમ જીતે છે, અને બંને પગલાંમાં ભૂલ કરવી સહેલી છે. અહીં RFC 9309 હેઠળ મેચિંગ કેવી રીતે થાય છે, ચાર ઉદાહરણો, અને ફાઇલ જાતે ચકાસવાની ત્રણ રીતો આપી છે.
આ પેજ પર
- Google Search Consoleના robots.txt Testerનું શું થયું?
- ક્રૉલર કેવી રીતે નક્કી કરે છે કે URLને મંજૂરી છે કે નહીં?
- શું robots.txt ટેસ્ટનું ઉદાહરણ વિગતે સમજાવી શકો?
- Googleનું open-source robots.txt parser કેવી રીતે ચલાવવું?
- શું હું Pythonના urllib.robotparserથી robots.txt ચકાસી શકું?
- robots.txt ટેસ્ટ પાસ થાય છતાં ક્રૉલર બ્લૉક કેમ રહે છે?
- દરેક AI ક્રૉલર માટે robots.txt એકસાથે કેવી રીતે તપાસવી?
Google Search Consoleના robots.txt Testerનું શું થયું?
November 2023માં Googleએ Search Consoleમાં robots.txt રિપોર્ટ ઉમેર્યો અને કહ્યું કે તે robots.txt tester બંધ કરી રહ્યું છે. આ રિપોર્ટ Settings હેઠળ છે અને ફક્ત Googleના ક્રૉલર આવરે છે. તે બતાવે છે:
- તમારી propertyના ટોચના 20 hosts માટે Googleને મળેલી robots.txt ફાઇલો.
- દરેક ફાઇલનું fetch status (
Fetched,Not Fetched - Not found (404)કેNot Fetched - Any other reason), Googleએ છેલ્લે ક્યારે તપાસી, અને bytesમાં તેનું કદ. - ફાઇલમાંની સમસ્યાઓ. Google કહે છે કે errors નિયમને વાપરતાં અટકાવે છે, જ્યારે warnings નથી અટકાવતી.
- છેલ્લા 30 દિવસમાં Googleએ મેળવેલાં વર્ઝન, અને ફાઇલ સુધાર્યા પછી ફરી crawl માગવાનું બટન.
રિપોર્ટ URL લઈને allowed કે blocked જવાબ આપતો નથી. Googlebot માટે એક URL તપાસવા Google URL Inspection tool તરફ, અને લોકલ ટેસ્ટિંગ માટે તેની open-source robots.txt library તરફ નિર્દેશ કરે છે. આમાંથી કોઈ GPTBot કે ClaudeBot જેવા AI ક્રૉલર વિશે કંઈ કહેતું નથી.
ક્રૉલર કેવી રીતે નક્કી કરે છે કે URLને મંજૂરી છે કે નહીં?
RFC 9309, Robots Exclusion Protocol, મેચિંગ વ્યાખ્યાયિત કરે છે. Google પોતાના ક્રૉલર માટે આ જ વર્તન દસ્તાવેજમાં આપે છે.
- Group પસંદ કરો. User-agent મેચિંગ case-insensitive છે. જો એક કે વધુ groups ક્રૉલરના tokenનું નામ આપે, તો તેમના નિયમો ભેગા થાય છે અને
User-agent: *group સંપૂર્ણ અવગણાય છે. ફક્ત જે ક્રૉલરનો નામવાળો group નથી તે જ*ને અનુસરે છે. - નિયમ પસંદ કરો. જેમનો પાથ URL સાથે મેળ ખાય એવા
AllowઅનેDisallowનિયમોમાંથી સૌથી વધુ અક્ષરોવાળો જીતે છે. જો એકAllowઅને એકDisallowસરખા લાંબા હોય, તોAllowજીતવો જોઈએ. - પેટર્ન વાંચો.
*અક્ષરોની કોઈ પણ શ્રેણી સાથે મેળ ખાય છે અને$URLનો અંત દર્શાવે છે. પાથ case-sensitive છે, તેથી/Admin/એ/admin/સાથે મેળ ખાતું નથી. - કોઈ નિયમ મેળ ન ખાય તો મંજૂરી છે.
/robots.txtપોતે હંમેશાં મંજૂર છે.
robots.txtનો response code તેના નિયમો જેટલો જ મહત્ત્વનો છે. 4xx response એટલે ક્રૉલર બધું મેળવી શકે; Google 429 સિવાયના દરેક 4xxને ફાઇલ ન હોય તેમ ગણે છે. 5xx response એટલે ક્રૉલરે માનવું પડે કે આખી સાઇટ પર મનાઈ છે. Google પહેલા 12 કલાક crawl બંધ કરે છે, પછી 30 દિવસ સુધી છેલ્લી સારી નકલ વાપરે છે. RFC 9309 ક્રૉલરને ઓછામાં ઓછા 500 KiB parse કરવાનું કહે છે, અને Google 500 KiB પછીનું બધું અવગણે છે.
શું robots.txt ટેસ્ટનું ઉદાહરણ વિગતે સમજાવી શકો?
અહીં એક default group અને નામ સાથેના બે AI ક્રૉલરવાળી નાની robots.txt છે:
Googlebotઅને/search/help/billing: મંજૂર. Googlebotનો group નથી, તેથી*group લાગુ પડે છે.Disallow: /searchઅનેAllow: /search/helpબંને મેળ ખાય છે, અનેAllowનિયમ વધુ લાંબો છે.GPTBotઅને/blog/post: બ્લૉક. GPTBotનો પોતાનો group છે, અનેDisallow: /દરેક પાથ સાથે મેળ ખાય છે.OAI-SearchBotઅને/admin/settings: મંજૂર. OAI-SearchBotનો પોતાનો group છે, તેથી*groupમાંનોDisallow: /admin/તેને લાગુ પડતો નથી. આ સૌથી સામાન્ય આશ્ચર્ય છે; સહિયારા નિયમો દરેક નામવાળા groupમાં ફરી લખો.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$ સરખી લંબાઈના કિસ્સા ઓછા છે પણ એ જ તર્કને અનુસરે છે. Googleના દસ્તાવેજમાં URL /folder/page માટે allow: /folder અને disallow: /folderનું ઉદાહરણ છે: બંને સરખા લાંબા છે, તેથી URLને મંજૂરી છે.
Googleનું open-source robots.txt parser કેવી રીતે ચલાવવું?
Google robots.txt નિયમો મેચ કરવા production માં વાપરે છે તે C++ library પ્રકાશિત કરે છે, સાથે લોકલ ફાઇલ સામે એક URL અને એક user agent ચકાસવા નાનો command-line પ્રોગ્રામ પણ. 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 Repository CMake build પણ વર્ણવે છે, જે એ જ arguments સાથે robots નામની binary બનાવે છે. ટૂલ ફક્ત parse અને match કરે છે; તે robots.txt ડાઉનલોડ કરતું નથી, તેથી પહેલાં live ફાઇલ સાચવો. તેનું README એ પણ નોંધે છે કે parsing અને matching સિવાયનું ક્રૉલર-વિશિષ્ટ વર્તન libraryનો ભાગ નથી.
શું હું Pythonના urllib.robotparserથી robots.txt ચકાસી શકું?
Pythonની standard libraryમાં એક parser છે જે user agent અને URL માટે allowed કે blocked જવાબ આપે છે. આ script ઉપરનું ઉદાહરણ ચકાસે છે:
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માં આવ્યો. જૂનાં releases, 3.12 અને તેની પહેલાંનાં બધાં સહિત, સૌથી લાંબો નહીં પણ ફાઇલના ક્રમમાં પહેલો મેળ ખાતો નિયમ લાગુ કરે છે, અને પાથમાં * કે $ સમજતાં નથી. આ વર્ઝન પર script પહેલો અને ચોથો ટેસ્ટ ઊંધો બતાવે છે: Googlebot /search/help/billing પરથી બ્લૉક અને OAI-SearchBotને PDF મેળવવાની મંજૂરી.
દરેક વર્ઝનમાં બીજા બે તફાવત લાગુ પડે છે. RobotFileParser.read() robots.txt માટેના 401 કે 403 responseને બધું disallow ગણે છે, જ્યારે RFC 9309 કહે છે કે 4xx એટલે બધું મેળવી શકાય. અને read() Pythonના default user agentથી ફાઇલ ડાઉનલોડ કરે છે, જેને અમુક ફાયરવૉલ બ્લૉક કરે છે, તેથી ટેસ્ટ તમારા નિયમો સાથે અસંબંધિત કારણોસર blocked બતાવી શકે. ઉપર મુજબ ફાઇલ જાતે મેળવીને parse()ને આપવાથી બંને ટળે છે.
robots.txt ટેસ્ટ પાસ થાય છતાં ક્રૉલર બ્લૉક કેમ રહે છે?
ટેસ્ટર એક જ પ્રશ્નનો જવાબ આપે છે: શું નિયમો આ URLને મંજૂરી આપે છે? ઘણી વસ્તુઓ એ જવાબની બહાર છે:
- Live ફાઇલ તમે ચકાસેલી ફાઇલથી જુદી છે, કે ક્રૉલર હજી cached નકલ વાપરે છે. RFC 9309 કહે છે કે ક્રૉલરે cached નકલ 24 કલાકથી વધુ ન વાપરવી જોઈએ, અને Google સામાન્ય રીતે 24 કલાક સુધી cache કરે છે.
- robots.txtનું URL HTML પેજ કે error આપે છે. Status 200 વાળા HTML પેજમાં કોઈ માન્ય નિયમ નથી, અને 5xx response આખી સાઇટ બ્લૉક કરે છે.
- 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 tester છે?
ના. November 2023માં Googleએ તેની જગ્યાએ robots.txt રિપોર્ટ મૂક્યો, જે Googleએ મેળવેલી ફાઇલો, તેમનું status અને કોઈ પણ errors બતાવે છે. Googlebot કોઈ ચોક્કસ URL crawl કરી શકે કે નહીં તે તપાસવા URL Inspection tool વાપરો.
શું robots.txtમાં Allow, Disallowને override કરે છે?
ફક્ત ત્યારે જ્યારે Allow નિયમ વધુ લાંબો કે બરાબર સરખો લાંબો હોય. સૌથી લાંબો મેળ ખાતો પાથ ધરાવતો નિયમ જીતે છે, ભલે તે ગમે તે પ્રકારનો હોય, અને સરખી લંબાઈમાં Allow જીતે છે.
શું robots.txt case-sensitive છે?
અંશતઃ. User-agentની વેલ્યૂ case જોયા વગર મેચ થાય છે, તેથી gptbot અને GPTBot એક જ groupનું નામ છે. પાથ case-sensitive છે, તેથી Disallow: /Private/ એ /private/ને બ્લૉક કરતું નથી.
robots.txt validator શું તપાસે છે?
Validator તપાસે છે કે ફાઇલ સુધી પહોંચી શકાય છે, text તરીકે મળે છે અને માન્ય syntaxમાં લખેલી છે. Tester એથી આગળ જઈને ચોક્કસ URL અને ક્રૉલર માટે નિર્ણય આપે છે. સામાન્ય રીતે બંનેની જરૂર પડે છે, કારણ કે માન્ય ફાઇલ પણ એવું પેજ બ્લૉક કરી શકે જેને તમે મંજૂરી આપવા માગતા હતા.
જો ક્રૉલરનો પોતાનો group હોય, તો શું તે હજી User-agent: *ને અનુસરે છે?
ના. એ ક્રૉલર માટે નામવાળો group * groupની જગ્યા સંપૂર્ણ લઈ લે છે. જે નિયમ તમે બધાને લાગુ કરવા માગો છો તે દરેક નામવાળા groupમાં ફરી લખવો પડે.
સ્રોતો
- 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