താരതമ്യം

Proof of Actor vs user agent അനുവദനപ്പട്ടികകൾ: ഒരു പേര് ഒരു അവകാശവാദമാണ്, തെളിവല്ല

User-Agent string പ്രകാരം allowlisting സജ്ജമാക്കാൻ വേഗമാണ്, മനസ്സിലാക്കാനും എളുപ്പമാണ്. പക്ഷേ അത് കബളിപ്പിക്കാനും എളുപ്പമാണ്, കാരണം header client അയയ്ക്കാൻ തീരുമാനിക്കുന്നതുതന്നെയാണ്. ഒരു user agent അനുവദനപ്പട്ടിക യഥാർത്ഥത്തിൽ നിങ്ങളോട് പറയുന്നത് എന്താണെന്നത്, network checks എവിടെ സഹായിക്കുന്നുവെന്ന്, കൂടാതെ Proof of Actor എങ്ങനെ declarations നെ verified evidence ൽ നിന്ന് വേർതിരിക്കുന്നുവെന്നും ഇവിടെ കാണിക്കുന്നു.

Early Access നേടുക ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് പര്യവേക്ഷണം ചെയ്യുക

രചിച്ചത് Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ചുരുക്ക ഉത്തരം

ഒരു user agent അനുവദനപ്പട്ടിക, client തന്റെ User-Agent header ൽ ഇടുന്ന ഏതൊരു പേരിനെയും വിശ്വസിക്കുന്നു, ആ പേര് ഏതൊരു client നും നൽകാം. Reverse DNS ഉം പ്രസിദ്ധീകരിച്ച IP ranges ഉം ചില operators ന് യഥാർത്ഥ തെളിവ് കൂട്ടിച്ചേർക്കുന്നു, എന്നാൽ അവ പ്രസിദ്ധീകരിക്കുന്ന operator മാർക്ക് മാത്രമേ അത് ബാധകമാകൂ. Proof of Actor header നെ ഒരു declaration ആയി കൈകാര്യം ചെയ്യുന്നു, agentകൾ അവരുടെ requests ഒപ്പിടുന്നിടത്ത് signatures പരിശോധിക്കുന്നു, തെളിവ് ദുർബലമായാൽ Unknown എന്ന് റിപ്പോർട്ട് ചെയ്യുന്നു, അതിനാൽ facts കാഴ്ചയിൽ വച്ച് നിങ്ങളുടെ code തീരുമാനിക്കുന്നു.

User agent അനുവദനപ്പട്ടിക വെബിലെ ഏറ്റവും പഴയ patterns ലൊന്നാണ്. നിങ്ങൾ വിശ്വസിക്കുന്ന crawler, client പേരുകളുടെ ഒരു പട്ടിക സൂക്ഷിക്കുന്നു. ഒരു request പൊരുത്തപ്പെടുന്ന User-Agent header സഹിതം എത്തുമ്പോൾ, അതിനെ കടത്തിവിടും, ഒരു challenge ഒഴിവാക്കും, അല്ലെങ്കിൽ അതിന് ലഘുവായ പേജ് നൽകും. ഇത് സജ്ജമാക്കാൻ മിനിറ്റുകൾ മതി, ടീമിലെ എല്ലാവർക്കും ഇത് മനസ്സിലാകും.

പ്രധാന automated സന്ദർശകർ ചില search crawlers ഉം കുറച്ച് monitoring tools ഉം മാത്രമായിരുന്ന കാലത്ത് ഈ pattern കൂടുതൽ യുക്തിയുക്തമായിരുന്നു. ഇന്ന്, AI agents, assistants, automated clients എന്നിവ വർധിച്ച തോതിൽ applications ലേക്ക് എത്തുന്നു, അവയിൽ പലതും ഒരു പേര് പ്രഖ്യാപിക്കുന്നു. ആ പേരുകളിൽ ചിലത് യഥാർത്ഥമാണ്. ചിലത് പകർത്തപ്പെട്ടതാണ്. header നിങ്ങൾക്ക് ഏതാണ് എന്ന് പറയില്ല.

Proof of Actor വ്യത്യസ്തമായ ഒരു സമീപനം സ്വീകരിക്കുന്നു. അത് ഒരു User-Agent string നെ അതെന്താണോ അതുപോലെ, ഒരു declaration ആയി കണക്കാക്കുന്നു, അതിനൊപ്പം കൂടുതൽ ശക്തമായ തെളിവ് ഉണ്ടെങ്കിൽ അത് കൂടി റിപ്പോർട്ട് ചെയ്യുന്നു. പേരുപ്രകാരമുള്ള allowlisting ന്റെ പരിധികൾ, network-level checks എവിടെ സഹായിക്കുന്നു, verified signatures ഉം വ്യക്തമായ Unknown class ഉം ചിത്രം എങ്ങനെ മാറ്റുന്നു എന്നതും ഈ പേജ് വിശദീകരിക്കുന്നു.

ചുരുക്കം

	User agent അനുവദനപ്പട്ടിക	Proof of Actor
പ്രധാന തെളിവ്	User-Agent header ലെ ഒരു പേര്	Signatures, declarations, signals എന്നിവ, ഓരോന്നിനും അതിന്റെ basis ലേബൽ ചെയ്തിരിക്കുന്നു
Client അത് കൃത്രിമമായി ഉണ്ടാക്കാമോ?	അതെ, അതേ string അയച്ച്	ഒരു declared basis അവകാശപ്പെടാം; ഒരു verified basis ന് signing key ആവശ്യമാണ്
Output	പട്ടികയിൽ ഉണ്ടോ ഇല്ലയോ	Human, Human + AI, Agent, അല്ലെങ്കിൽ Unknown, കൂടാതെ ഒരു basis
വ്യക്തമല്ലാത്ത traffic	അനുവദനപ്പട്ടികയിൽ ഇല്ലെന്ന് കണക്കാക്കുന്നു, അല്ലെങ്കിൽ default ആയി അനുവദിക്കുന്നു	Unknown, ഓരോ route നും നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന fallback സഹിതം
AI സഹായത്തോടെ പ്രവർത്തിക്കുന്ന ആളുകൾ	കാണാനില്ല; അവർ സാധാരണ browsers ഉപയോഗിക്കുന്നു	പ്രഖ്യാപിക്കുകയോ നിരീക്ഷിക്കുകയോ ചെയ്താൽ Human + AI എന്ന വ്യത്യസ്ത class
പരിപാലനം	പേരുകൾ മാറുമ്പോൾ പട്ടിക കൈയ്യോടെ പുതുക്കുന്നു	Agent operators പ്രസിദ്ധീകരിച്ച keys; നിങ്ങളുടെ code ലെ policies
Install ചെയ്തപ്പോൾ default	പട്ടിക അനുവദിക്കുന്നതെന്തുമോ അതാണ്	Observation; നിങ്ങൾ ഒരു policy ചേർക്കുന്നതുവരെ ഒന്നും മാറില്ല
ഏറ്റവും അനുയോജ്യം	നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്ന, അറിയപ്പെടുന്ന clients നെ കുറഞ്ഞ ചെലവിൽ route ചെയ്യുന്നത്	product, policy തീരുമാനങ്ങൾക്ക് evidence-based actor context

ബാക്കിയുള്ള പേജ് ഓരോ വരിയും വിശദീകരിക്കുന്നു.

User-Agent പ്രകാരം allowlisting എന്തുകൊണ്ട് spoof ചെയ്യാവുന്നതാണ്

User-Agent header client ആണ് സജ്ജമാക്കുന്നത്. ഒരു browser അത് സജ്ജമാക്കും, ഒരു script അത് സജ്ജമാക്കും, ഒരു agent framework അത് സജ്ജമാക്കും. HTTP ൽ ആ value സത്യമായിരിക്കണമെന്ന് പരിശോധിക്കുന്ന ഒന്നുമില്ല. നിങ്ങളുടെ allowlist ഒരു string നെ വിശ്വസിക്കുന്നുവെങ്കിൽ, ആ string പകർന്നെടുക്കുന്ന ആര്ക്കും അതേ പരിഗണന ലഭിക്കും.

ഇതിനെ user agent spoofing എന്നു വിളിക്കുന്നു, കാരണം ലളിതമാണ്: ഇതിന് ചിലവും ഇല്ല. ഒരു challenge ഒഴിവാക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു scraper ന്, നിങ്ങൾ വിശ്വസിക്കുന്ന crawler ന്റെ പേര് കടംവാങ്ങിയാൽ മതി. തെറ്റായി പെരുമാറുന്ന ഒരു client താൻ ഒരു ജനപ്രിയ assistant ആണെന്ന് അവകാശപ്പെടാം. ഒരു library default കാരണം ഒരു legitimate tool പോലും generic browser string അയയ്ക്കാം.

ഫലമായി user agent അനുവദനപ്പട്ടികയ്ക്ക് രണ്ട് failure modes ഉണ്ട്:

False trust: വിശ്വസിക്കരുതാത്ത ഒരു client വിശ്വസനീയമായ പേര് അവകാശപ്പെട്ടു കടന്നുപോകുന്നു.
False doubt: ഒരു നിയമപരമായ client അപ്രതീക്ഷിതമായ അല്ലെങ്കിൽ generic string അയയ്ക്കുകയും പരാജയപ്പെടുകയും ചെയ്യുന്നു.

ഈ രണ്ടിൽ ഒന്നും header മാത്രം നോക്കി കാണാനാവില്ല. അതാണ് പ്രധാന പരിധി, പട്ടിക പരിപാലനം എത്ര ചെയ്താലും അത് നീങ്ങുന്നില്ല.

ഇതൊന്നും User-Agent strings അവഗണിക്കണം എന്നർത്ഥമല്ല. നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്ന crawlers ഉം agents ഉം സത്യസന്ധമായി തങ്ങളെ പ്രഖ്യാപിക്കുന്നു, routing, analytics, debugging എന്നിവയ്ക്ക് പേര് ഉപകാരപ്രദമായ ഒരു സൂചനയാണ്. ഒരു client താനെന്താണെന്ന് പറയുന്നതാണ് അത് നിങ്ങൾക്ക് അറിയിക്കുന്നത്.

ആ വിവരത്തിന് ശരിയായ സ്ഥലം ഒരു declaration ആയി, മറ്റ് തെളിവുകളോടൊപ്പം തൂക്കമിട്ട്, അതിന്റെ സ്വന്തം പോലെ access തുറക്കുന്ന key ആയി അല്ല. Proof of Actor അത് അതേ രീതിയിൽ തന്നെ രേഖപ്പെടുത്തുന്നു.

Reverse DNS, IP പട്ടികകൾ: ഭാഗികമായ measures

പല teams ഉം network checks കൊണ്ട് ഒരു അനുവദനപ്പട്ടിക ശക്തമാക്കുന്നു. അവ സഹായിക്കുന്നു, കൂടാതെ കൃത്യമായി മനസ്സിലാക്കുന്നതും മൂല്യമുള്ളതാണ്.

Reverse DNS verification

ചില crawler operators ഒരു verification process രേഖപ്പെടുത്തുന്നു: request ന്റെ IP address ന് hostname കണ്ടെത്തുക, അത് operator ന്റെ domain ലാണോ എന്ന് പരിശോധിക്കുക, പിന്നെ ആ hostname വീണ്ടും കണ്ടെത്തി അത് അതേ IP ലേക്ക് resolve ചെയ്യുന്നുണ്ടോ എന്ന് സ്ഥിരീകരിക്കുക. ഈ round trip വിജയിക്കുമ്പോൾ, ആ request operator ന്റെ infrastructure ല്നിന്നാണ് വന്നതെന്ന് യഥാർത്ഥ തെളിവ് നിങ്ങൾക്കുണ്ട്.

പരിധികൾ പ്രായോഗികമാണ്. അത് രേഖപ്പെടുത്തി പിന്തുണയ്ക്കുന്ന operators ന് മാത്രമേ പ്രവർത്തിക്കൂ. cache ചെയ്യേണ്ട DNS lookups ഇത് കൂട്ടിച്ചേർക്കും. കൂടാതെ request ഏത് network ലാണ് വന്നത് എന്നതിനെക്കുറിച്ചാണ് ഇത് പറയുന്നത്, ആ network ല് ഏത് product അല്ലെങ്കിൽ agent ആണ് request ചെയ്തത് എന്നതിനെക്കുറിച്ച് അല്ല.

Published IP ranges

മറ്റ് operators അവരുടെ automated clients ഉപയോഗിക്കുന്ന IP ranges പ്രസിദ്ധീകരിക്കുന്നു. ഒരു request നെ ആ ranges ന് എതിരായി പൊരുത്തപ്പെടുത്തുന്നത് വേഗത്തിലാണ്, കൂടാതെ reverse DNS ന് സമാനമായ തെളിവും നൽകുന്നു. ഈ ranges പ്രസിദ്ധീകരിക്കാൻ ഒരു standard format സംബന്ധിച്ച് IETF യിൽ തുടരുന്ന ചർച്ചകൾ ഉണ്ട്, എന്നാൽ 2026 നവംബർ വരെയും settled standard ഒന്നുമില്ല, coverage ഓരോ operator പ്രസിദ്ധീകരിക്കാൻ തിരഞ്ഞെടുക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കും.

മറ്റും കൂടുതൽ agents shared cloud infrastructure ൽ, proxies ന് പിന്നിൽ, അല്ലെങ്കിൽ user ന്റെ സ്വന്തം device ൽ പ്രവർത്തിക്കുമ്പോൾ IP evidence ദുർബലമാകുന്നു. ഒരു cloud address ന് അനേകം ബന്ധമില്ലാത്ത clients ഹോസ്റ്റ് ചെയ്യാം, ഒരു person's browser ൽ നിന്നു പ്രവർത്തിക്കുന്ന ഒരു agent ആ വ്യക്തിയുടെ network പോലെ തന്നെ കാണപ്പെടും.

Network checks ഒടുവിൽ നൽകുന്നത് എന്ത്

Reverse DNS ഉം IP പട്ടികകളും അറിയപ്പെടുന്ന operators ന്റെ ഒരു ഉപവിഭാഗത്തിന് ചില declarations നെ കൂടുതൽ ശക്തമായ ഒന്നാക്കി മാറ്റുന്നു. അവ agents, tools എന്നിവയുടെ നീണ്ട tail നെ ഉൾക്കൊള്ളുന്നില്ല, AI യോടൊപ്പം പ്രവർത്തിക്കുന്ന ആളുകൾക്കു ഒട്ടും സഹായിക്കില്ല. അവ ഭാഗികമായ measures ആണ്: ഉപയോഗിക്കാൻ വിലമതിക്കപ്പെടുന്നവ, പക്ഷേ സ്വയം മതിയാകാത്തവ.

Signatures vs declarations

തെളിവിന്റെ കൂടുതൽ ശക്തമായ രൂപം ഒരു cryptographic signature ആണ്. RFC 9421 ൽ നിർവചിച്ചിരിക്കുന്ന HTTP Message Signatures ഉപയോഗിച്ച്, ഒരു client ഓരോ request ന്റെയും തെരഞ്ഞെടുക്കപ്പെട്ട ഭാഗങ്ങൾ private key കൊണ്ട് ഒപ്പിടുന്നു. verifier operator ന്റെ പ്രസിദ്ധീകരിച്ച public key കൊണ്ടുവന്ന് signature പരിശോധിക്കുന്നു. അത് verify ചെയ്താൽ, ആ request ആ key കൈവശമുള്ളയാൾ ഒപ്പിട്ടതാണ്, കൂടാതെ sign ചെയ്ത ഭാഗങ്ങൾ വഴിയിൽ മാറ്റപ്പെട്ടിട്ടില്ല.

IETF Web Bot Auth working group automated clients എങ്ങനെ ഈ signatures ഉപയോഗിക്കുന്നു, അവരുടെ keys എങ്ങനെ പ്രസിദ്ധീകരിക്കുന്നു എന്നിവ standardize ചെയ്യുകയാണ്. Web Bot Auth for product teams എന്ന ഞങ്ങളുടെ explainer നിലവിലെ സ്ഥിതി വിശദീകരിക്കുന്നു.

Proof of Actor സാധുവായ signature നെ verified തെളിവായി ഉപയോഗിക്കുന്നു. ഒരു User-Agent string, ഒരു client hint, അല്ലെങ്കിൽ request body യിലെ ഒരു self-description എന്നിവ declared ആയി കണക്കാക്കപ്പെടുന്നു. Behavioral ഉം contextual ഉം ആയ signals inferred ആയി കണക്കാക്കപ്പെടുന്നു, അതുപോലെ ലേബൽ ചെയ്യുന്നു. ഓരോ ഫലവും അത് ഏത് basis ലാണ് ആശ്രയിക്കുന്നത് എന്ന് പറയുന്നു, അതിനാൽ നിങ്ങളുടെ ടീം ഒരിക്കലും അവകാശവാദം ഒരു പരിശോധനയായി തെറ്റിദ്ധരിക്കില്ല. പൂർണ്ണ നിർവചനങ്ങൾക്ക് evidence basis entry കാണുക.

ഒരു verified തെളിവിനും ഒരു പരിധി നിലനിൽക്കുന്നു. സാധുവായ signature request ഒപ്പിട്ട key ഏതാണെന്ന് തെളിയിക്കുന്നു. agent അത് ചോദിക്കുന്ന കാര്യം ചെയ്യാൻ അനുവദനീയമാണെന്ന് അത് തെളിയിക്കുന്നില്ല. അത് ഒരു agent authorization ചോദ്യം ആണ്, അത് നിങ്ങളുടെ application ല് തുടരുന്നു.

അനുമാനം ചെയ്യുന്നതിനു പകരം Unknown കൈകാര്യം ചെയ്യുക

ഒരു അനുവദനപ്പട്ടിക ഓരോ request നെയും രണ്ട് വിഭാഗങ്ങളിൽ ഒന്നിലാക്കി തീർക്കുന്നു: പട്ടികയിൽ അല്ലെങ്കിൽ അല്ല. പ്രായോഗികമായി അതായത് വ്യക്തമല്ലാത്ത traffic നിങ്ങളുടെ default എന്താണോ അതാകും ലഭിക്കുക, സാധാരണയായി ആ default മുഴുവൻ site നും ഒരിക്കൽ മാത്രം തെരഞ്ഞെടുക്കപ്പെടുന്നു.

Proof of Actor Unknown നെ ഒരു ആദ്യ-class ഫലമായി കണക്കാക്കുന്നു. തെളിവ് വിശ്വസനീയമായ ഒരു നിഗമനത്തെ പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ, അത് അനുമാനിക്കാതെ അങ്ങനെ തന്നെ പറയുന്നു. തുടർന്ന് നിങ്ങളുടെ policies ഓരോ route ലും Unknown എന്നതിന്റെ അർത്ഥം തീരുമാനിക്കുന്നു:

പൊതുവായ documentation അല്ലെങ്കിൽ marketing pages ൽ, അതിനെ അനുവദിക്കുക.
search അല്ലെങ്കിൽ listing endpoints ൽ, നിങ്ങളുടെ സാധാരണ rate limits സഹിതം അനുവദിക്കുക.
account മാറ്റങ്ങളിൽ, നിങ്ങളുടെ നിലവിലുള്ള checks നിലനിർത്തുക.
ഉയർന്ന പ്രാധാന്യമുള്ള actions ൽ, അത് review ലേക്ക് അയയ്ക്കുക അല്ലെങ്കിൽ കൂടുതൽ ശക്തമായ signal അഭ്യർത്ഥിക്കുക.

handling Unknown traffic എന്ന guide ഉം unknown classification entry യും patterns വിശദീകരിക്കുന്നു. നിങ്ങളുടെ Unknown rate കാലക്രമത്തിൽ പിന്തുടരുന്നതും നിങ്ങളുടെ traffic ന്റെ എത്ര ഭാഗം ഇപ്പോഴും ദുർബലമായ തെളിവിൽ ആശ്രയിക്കുന്നുവെന്ന് കാണിക്കുന്നു.

AI സഹായത്തോടെ പ്രവർത്തിക്കുന്ന ആളുകളെക്കുറിച്ച് എന്ത്?

ഒരു സാധാരണ browser ൽ AI assistant ഉപയോഗിക്കുന്ന ഒരു വ്യക്തിയെക്കുറിച്ച് ഒരു user agent അനുവദനപ്പട്ടികയ്ക്ക് ഒന്നും പറയാനില്ല. അവരുടെ User-Agent ഒരു സാധാരണ browser string ആണ്. എന്നിരുന്നാലും പല products ഉം ആ interaction തിരിച്ചറിയാൻ ആഗ്രഹിക്കുന്നു, ഉദാഹരണത്തിന് AI drafted submissions ലേബൽ ചെയ്യാൻ അല്ലെങ്കിൽ AI സഹായത്തോടെ പ്രവർത്തിക്കുന്ന users onboarding വഴി എങ്ങനെ നീങ്ങുന്നു എന്ന് മനസ്സിലാക്കാൻ.

പിന്തുണയ്ക്കുന്ന ഒരു integration മുഖേന സഹായം പ്രഖ്യാപിക്കുകയോ നിരീക്ഷിക്കുകയോ ചെയ്താൽ Proof of Actor ഈ interactions നെ Human + AI ആയി റിപ്പോർട്ട് ചെയ്യുന്നു. എഴുത്തിന്റെ ശൈലി മാത്രം നോക്കി അത് അനുമാനിക്കുന്നില്ല. കൂടുതൽ അറിയാൻ AI-assisted interaction കാണുക.

ഒരു അനുവദനപ്പട്ടികയിൽ നിന്ന് evidence-based policies ലേക്ക് മാറുക

ആദ്യ ദിവസം തന്നെ നിങ്ങളുടെ അനുവദനപ്പട്ടിക നീക്കം ചെയ്യേണ്ടതില്ല. സുരക്ഷിതമായ ഒരു വഴി ഇങ്ങനെയാണ്:

Observation mode ൽ ഇൻസ്റ്റാൾ ചെയ്യുക. Proof of Actor ഒന്നും മാറ്റുന്നില്ല. നിങ്ങളുടെ അനുവദനപ്പട്ടിക പ്രവർത്തിച്ചുകൊണ്ടിരിക്കും.
താരതമ്യം ചെയ്യുക. ഓരോ route നും, ഏത് അനുവദനപ്പട്ടികപ്പെടുത്തിയ requests ന് verified തെളിവ് ഉണ്ടെന്ന്, ഏവയ്ക്ക് declaration മാത്രം ഉണ്ടെന്ന്, ഏവ Unknown ൽ അവസാനിക്കുന്നുവെന്ന് കാണുക.
Policies preview ചെയ്യുക. verified agents, declared agents, Unknown എന്നിവയെ വ്യത്യസ്തമായി കൈകാര്യം ചെയ്യുന്ന ഒരു policy കരട് തയ്യാറാക്കി, യഥാർത്ഥ traffic ലെ അതിന്റെ പ്രഭാവം preview ചെയ്യുക.
Route by route ആയി enforce ചെയ്യുക. spoof ചെയ്ത ഒരു പേര് ഏറ്റവും പ്രധാനമാകുന്ന routes ൽ നിന്ന് ആരംഭിക്കുക.
അവശ്യ സൂചനയായി അനുവദനപ്പട്ടിക നിലനിർത്തുക. പേരുകൾ ഇപ്പോഴും routing, analytics എന്നിവയ്ക്ക് ഉപകാരപ്പെടും, ഇപ്പോൾ അവയുടെ basis ദൃശ്യമാകും.

rolling out actor-aware policies safely എന്ന guide ഓരോ ഘട്ടവും ഉൾക്കൊള്ളുന്നു, verified automated requests signed clients എങ്ങനെ fit ചെയ്യുന്നു എന്ന് വിശദീകരിക്കുന്നു.

എപ്പോൾ ഒരു അനുവദനപ്പട്ടിക മതിയാകും

കുറഞ്ഞ പ്രാധാന്യമുള്ള routing ന്, ഉദാഹരണത്തിന് പൊതുവായ content ൽ അറിയപ്പെടുന്ന crawler ന് ലഘുവായ പേജ് നൽകുന്നത് പോലുള്ള സാഹചര്യങ്ങളിൽ, ഒരു user agent അനുവദനപ്പട്ടിക പലപ്പോഴും മതി. spoof ചെയ്ത പേരിന്റെ ചെലവ് ചെറിയതാണ്.

ഒരു തീരുമാനത്തിന് പ്രത്യാഘാതങ്ങൾ ഉണ്ടാകുമ്പോൾ, ഉദാഹരണത്തിന് ഒരു challenge ഒഴിവാക്കുക, കൂടുതൽ സമൃദ്ധമായ data പുറത്ത് വിടുക, അല്ലെങ്കിൽ ഒരു write അനുവദിക്കുക, നിങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയുന്ന തെളിവ് വേണം. അതാണ് Proof of Actor ന്റെ സ്ഥാനം, നിങ്ങൾ ഇതിനകം പ്രവർത്തിപ്പിക്കുന്ന network checks ഉം edge controls ഉം സഹിതം പ്രവർത്തിക്കുന്നത്.

ആരംഭിക്കുക

Proof of Actor private beta ലാണ്. തിരഞ്ഞെടുത്ത founding developer teams ന് അംഗീകരിച്ച usage limits ൽ, സ്വയം billing ആരംഭിക്കാതെ, 12 months വരെ സൗജന്യ access ലഭിക്കാം. early access അപേക്ഷിക്കുക and ഇന്ന് നിങ്ങൾ ഏത് clients നെ അനുവദനപ്പട്ടികയിൽ വെയ്ക്കുന്നു, ഏത് routes നെ കൂടുതൽ മികച്ച തെളിവോടെ സംരക്ഷിക്കാനാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത് എന്നതും ഞങ്ങളെ അറിയിക്കുക.

ഡെവലപ്പർമാർക്കായി

What your code receives

Every interaction resolves to one result record. Your application reads the class and the basis and applies its own policy.

Result record

{
  "route": "GET /api/v1/catalog",
  "class": "agent",
  "basis": "verified",
  "evidence": [
    { "signal": "http_message_signature", "result": "valid", "keyid": "assistant.example" },
    { "signal": "client_declaration", "value": "assistant.example" }
  ],
  "observed_at": "2026-11-13T10:42:07Z"
}

class: Human, Human + AI, Agent അല്ലെങ്കിൽ Unknown.
basis: തെളിവ് എത്ര ശക്തമാണെന്നത്: verified, declared, inferred അല്ലെങ്കിൽ unknown.
evidence: result-ിന്റെ പിന്നിലെ signals, അതുവഴി നിങ്ങളുടെ team-ന് കാരണം കാണാൻ കഴിയും.

observation mode-ൽ ആരംഭിക്കുക: നിങ്ങളുടെ logs-ിന് ഒപ്പം results രേഖപ്പെടുത്തുക, നിങ്ങൾ ഒരു policy തിരഞ്ഞെടുക്കും വരെ ഒന്നും മാറ്റരുത്. Node.js integration guide വായിക്കുക

പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

ഒരു user agent അനുവദനപ്പട്ടിക ഉപയോഗശൂന്യമാണോ?

അല്ല. നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്ന clients നൽകുന്ന ഒരു ഉപകാരപ്രദമായ declaration ആണ് അത്, കൂടാതെ അറിയപ്പെടുന്ന crawlers നെ route ചെയ്യാനുള്ള ഒരു കുറഞ്ഞ ചെലവിലുള്ള മാർഗവും ആണ്. പ്രശ്നം അതിനെ proof ആയി കാണുന്നതിലാണ്. ഏതൊരു client നും ഏതൊരു User-Agent string അയയ്ക്കാം, അതിനാൽ ഒരു അനുവദനപ്പട്ടിക മാത്രം sensitive actions തുറക്കാൻ ഒരിക്കലും ഉപയോഗിക്കരുത്.

Reverse DNS verification, User-Agent spoofing നെ പരിഹരിക്കുമോ?

അത് അത് രേഖപ്പെടുത്തിയിരിക്കുന്ന operators ന് സഹായിക്കുന്നു. ഒരു reverse lookup പിന്നെ matching forward lookup നടത്തി ഒരു IP address നെ operator ന്റെ domain ന് ബന്ധിപ്പിക്കുന്നു. അത് പിന്തുണയ്ക്കുന്ന operators ക്ക് മാത്രമേ പ്രവർത്തിക്കൂ, കൂടാതെ shared cloud അല്ലെങ്കിൽ residential addresses ലെ traffic സംബന്ധിച്ച് ഒന്നും പറയുന്നില്ല.

Proof of Actor, User-Agent header നെ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു?

ഒരു declaration ആയി. അത് declared basis ആയി ഫലത്തിൽ സംഭാവന ചെയ്യുന്നു, ഒരിക്കലും verified basis ആയി അല്ല. ഒരു verified basis ന് published key യുമായി പരിശോധിച്ച HTTP Message Signature പോലുള്ള തെളിവ് ആവശ്യമാണ്.

ഒരു verified signature എന്താണ് തെളിയിക്കുന്നത്?

ആ request ഒപ്പിട്ടത് ഏത് key ആണെന്നും signed ചെയ്ത ഭാഗങ്ങൾ മാറ്റിയിട്ടില്ലെന്നുമാണ് അത് തെളിയിക്കുന്നത്. ആ agent ന് ആ action നടത്താൻ അധികാരമുണ്ടെന്ന് അത് തെളിയിക്കുന്നില്ല. Authorization നിങ്ങളുടെ application ലാണ് തുടരുന്നത്.

ഒരു അറിയപ്പെടുന്ന agent ആണെന്ന് അവകാശപ്പെടുന്ന പക്ഷേ verify ചെയ്യാൻ കഴിയാത്ത clients ന് എന്ത് സംഭവിക്കും?

തെളിവ് പിന്തുണയ്ക്കുന്നതാണ് Proof of Actor റിപ്പോർട്ട് ചെയ്യുന്നത്, പലപ്പോഴും declared അല്ലെങ്കിൽ inferred ഫലം, അല്ലെങ്കിൽ Unknown. അവകാശപ്പെട്ട പേരിൽ വിശ്വസിക്കുന്നതിനു പകരം ആ route ന് വേണ്ട fallback നിങ്ങളുടെ policy തിരഞ്ഞെടുക്കുന്നു.

Proof of Actor ചേർക്കുന്നത് എന്റെ നിലവിലെ അനുവദനപ്പട്ടിക പെരുമാറ്റം മാറ്റുമോ?

ഇല്ല. അത് observation mode ൽ ആരംഭിക്കുന്നു. ഒന്നും മാറ്റുന്നതിന് മുൻപ് യഥാർത്ഥ traffic ൽ അതിന്റെ ഫലങ്ങൾ നിങ്ങളുടെ അനുവദനപ്പട്ടിക തീരുമാനങ്ങളുമായി താരതമ്യം ചെയ്യാം.

നിങ്ങളുടെ app ഉപയോഗിക്കുന്നത് ആരാണെന്ന് അറിയുക.

ചെറിയൊരു founding developers ഗ്രൂപ്പിനായുള്ള private beta.

Early Access നേടുക വിലകൾ കാണുക

ആദ്യം സംസാരിക്കണമോ? സ്ഥാപകരുമായി സംസാരിക്കുക