ତୁଳନା

Proof of Actor ବନାମ API bot ସୁରକ୍ଷା: keys କିଏ payment କରୁଛି ଜଣାଇଦେଉଥାଏ, actor context କିଏ କାର୍ଯ୍ୟ କରୁଛି ଜଣାଇଦେଉଥାଏ

API gateways, WAF bot rules, API keys ଏବଂ rate limits ଆପଣଙ୍କ API କୁ ଉପଲବ୍ଧ ଏବଂ ଦାୟୀ ରଖିଥାଏ। କିନ୍ତୁ ସେଗୁଡ଼ିକ ଏହା କହିବା ପାଇଁ ତିଆରି ହୋଇନଥିଲା ଯେ ଏକ request କି ଏକ app ମଧ୍ୟରେ ଥିବା ଜଣେ ବ୍ୟକ୍ତିଙ୍କ ଠାରୁ, ଜଣେ assistant ସହିତ କାମ କରୁଥିବା ବ୍ୟକ୍ତିଙ୍କ ଠାରୁ, କିମ୍ବା ଏକ autonomous agent ଠାରୁ ଆସିଛି। API ପାଇଁ bot management କେମିତି Proof of Actor ସହିତ ତୁଳନା ହୁଏ, ଏବଂ ଦୁଇଟି କିପରି ଏକାସାଙ୍ଗେ fit ହୁଏ, ଏଠାରେ ଦେଖନ୍ତୁ।

Early Access ପାଆନ୍ତୁ ଏହା କିପରି କାମ କରେ ଅନୁସନ୍ଧାନ କରନ୍ତୁ

ଦ୍ୱାରା Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ସଂକ୍ଷିପ୍ତ ଉତ୍ତର

API ପାଇଁ bot management ଆପଣଙ୍କ endpoints କୁ ସୁରକ୍ଷା ଦିଏ: gateway keys authenticate କରେ, WAF bot rules abusive traffic filter କରେ, ଏବଂ rate limits volume କୁ cap କରେ। Proof of Actor ଏକ ଭିନ୍ନ layer ଯୋଡ଼ିଥାଏ, ଯାହା ଆପଣଙ୍କ API କୁ କହିଦିଏ ଯେ ପ୍ରତ୍ୟେକ caller Human, Human + AI, Agent କିମ୍ବା Unknown କି, ଏବଂ ତାହାର ପଛର evidence କଣ, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ code ପ୍ରତ୍ୟେକଟିକୁ ସଠିକ ଭାବରେ serve କରିପାରେ। ଅଧିକାଂଶ teams ଦୁଇଟିକୁ ଏକାସାଙ୍ଗେ ଚଲାନ୍ତି।

API ଗୁଡ଼ିକର traffic model ପୂର୍ବେ ସରଳ ଥିଲା। ଜଣେ developer register କଲେ, ଏକ key ପାଇଲେ, ଏକ integration ଲେଖିଲେ, ଏବଂ ସେ integration ଆପଣଙ୍କ endpoints କୁ ଏକ schedule ଅନୁସାରେ କିମ୍ବା user କିଛି click କଲେ ବେଳେ call କଲା। API ପାଇଁ bot management ଏହି model ର ଆସପାସରେ ବିକାଶ ପାଇଲା: key authenticate କରନ୍ତୁ, volume cap କରନ୍ତୁ, ସ୍ପଷ୍ଟ ଭାବରେ abusive traffic filter କରନ୍ତୁ, ଏବଂ ଅନ୍ୟ ସମସ୍ତଙ୍କ ପାଇଁ service କୁ available ରଖନ୍ତୁ।

ଏହି model ଏଯାଏଁ ଚାଲିଛି, ଏବଂ ଏହା ପାଇଁ ତିଆରି ହୋଇଥିବା tools ଏବେ ମଧ୍ୟ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ। ପରିବର୍ତ୍ତନ ହେଲା calls ର ପଛରେ କିଏ ଅଛି। ସମାନ API key ଏବେ ଆପଣଙ୍କ customer ଙ୍କ app ବ୍ୟବହାର କରୁଥିବା ଜଣେ ବ୍ୟକ୍ତି, କାମ କରିବାକୁ AI assistant କୁ କହିଥିବା ଜଣେ ବ୍ୟକ୍ତି, ଏବଂ ରାତିଭରି ଏକ multi-step task ଚଲାଉଥିବା autonomous agent ଠାରୁ request ବହନ କରିପାରେ। ଆପଣଙ୍କ existing controls ଗୋଟିଏ key ଏବଂ ଗୋଟିଏ request rate ଦେଖେ। ଆପଣଙ୍କ product, support ଏବଂ policy decisions ଅନେକ ସମୟରେ ଅଧିକ କିଛି ଜାଣିବାକୁ ଚାହାଁନ୍ତି।

Proof of Actor ସେଇ gap ପୂରଣ କରେ। ଏହା ଆପଣଙ୍କ API କୁ ପ୍ରତ୍ୟେକ request ରେ କିଏ କିମ୍ବା କ’ଣ acting କରୁଛି ତାହା କହେ ଏବଂ evidence ବର୍ଣ୍ଣନା କରେ, ତାପରେ decision କୁ ଆପଣଙ୍କ code ଉପରେ ଛାଡ଼ିଦିଏ। ଏହି page ଏହାକୁ API bot protection ର ପ୍ରମୁଖ layers ସହିତ compare କରେ, ଯାହାଦ୍ୱାରା କେଉଁଟି କେଉଁଠି fit ହୁଏ ଆପଣ ଦେଖିପାରିବେ।

ସଂକ୍ଷିପ୍ତ ସଂସ୍କରଣ

	API bot ସୁରକ୍ଷା	Proof of Actor
ପ୍ରଧାନ ପ୍ରଶ୍ନ	ଏହି request କି allowed, authenticated, ଏବଂ limits ମଧ୍ୟରେ ଅଛି?	କିଏ କିମ୍ବା କ’ଣ acting କରୁଛି, ଏବଂ evidence କଣ?
ସାଧାରଣ layers	API gateway, WAF bot rules, API keys, rate limits	ଆପଣଙ୍କ API କିମ୍ବା MCP server ମଧ୍ୟରେ actor classification
କାହାକୁ ଚିହ୍ନଟ କରେ	key ର ମାଲିକ account କିମ୍ବା integration	ପ୍ରତ୍ୟେକ request ପଛର actor: Human, Human + AI, Agent କିମ୍ବା Unknown
Output	Allow, reject, throttle; କେବେ କେବେ bot score	ଗୋଟିଏ class ସହିତ basis: verified, declared, inferred କିମ୍ବା unknown
ଅସ୍ପଷ୍ଟ traffic	ସାଧାରଣତଃ allowed, ଯଦି key valid ଅଛି, କିମ୍ବା rule ଦ୍ୱାରା rejected	Unknown, route ଅନୁସାରେ ଆପଣ ଯାହା fallback ବାଛନ୍ତି ସେଥିସହିତ
response କିଏ ନିର୍ଣ୍ଣୟ କରେ	Gateway ଏବଂ WAF configuration	ଆପଣଙ୍କ application code
install ପରେ default	Enforcement	Observation; policy add କରିବା ପର୍ଯ୍ୟନ୍ତ କିଛି ବଦଳେନାହିଁ
ସର୍ବଶ୍ରେଷ୍ଠ କାମ	Availability, abuse filtering, quotas, accountability	ପ୍ରତ୍ୟେକ actor କୁ ସଠିକ ଭାବରେ serve କରିବା ଏବଂ API usage ବୁଝିବା

ତଳେ ଥିବା sections ପ୍ରତ୍ୟେକ ଭାଗକୁ ବ୍ୟାଖ୍ୟା କରନ୍ତି।

API bot ସୁରକ୍ଷା କ’ଣ ଭଲ କରେ

ପ୍ରତ୍ୟେକ layer କେଉଁ କାମ କରେ ତାହା ସ୍ପଷ୍ଟ କରିବା ଉପଯୋଗୀ, କାରଣ Proof of Actor ସବୁର ପାଖରେ ବସିବା ପାଇଁ ତିଆରି ହୋଇଛି, କୌଣସିଟିକୁ replace କରିବା ପାଇଁ ନୁହେଁ।

API gateways

Gateway ହେଉଛି ଆପଣଙ୍କ API ପାଇଁ front door। ଏହା connections terminate କରେ, API keys କିମ୍ବା tokens authenticate କରେ, requests କୁ ସଠିକ service କୁ route କରେ, quotas enforce କରେ ଏବଂ ପ୍ରାୟତଃ billing ଏବଂ analytics ପାଇଁ usage record କରେ। ଏହା "ଏହି caller ଭିତରକୁ ଯିବାକୁ allowed କି, ଏବଂ କେଉଁ door ଦ୍ୱାରା?" ଏହି ପ୍ରଶ୍ନର ଉତ୍ତର ଶୀଘ୍ର ଏବଂ ସମରୂପ ଭାବରେ ପ୍ରତ୍ୟେକ endpoint ଉପରେ ଦିଏ।

WAF bot rules

Bot rules ସହିତ ଏକ web application firewall traffic କୁ ଜଣାଶୁଣା attack pattern ଏବଂ abusive automation ପାଇଁ inspect କରେ। ଏହା injection attempts filter କରିପାରେ, abuse ଇତିହାସ ଥିବା sources ର traffic block କରିପାରେ, ଏବଂ scraping କିମ୍ବା credential attacks ଭଳି ଦେଖାଯାଉଥିବା requests କୁ challenge କିମ୍ବା drop କରିପାରେ। ଯେ traffic କେବେ ଆପଣଙ୍କ code ପର୍ଯ୍ୟନ୍ତ ପହଞ୍ଚିବା କଥା ନୁହେଁ, ସେଥିପାଇଁ ଏହା ଆପଣଙ୍କ ସର୍ବୋତ୍ତମ defense।

API keys ଏବଂ tokens

Keys ଏବଂ tokens ଆପଣଙ୍କୁ accountability ଦିଏ। ପ୍ରତ୍ୟେକ request ଏକ account ସହିତ map ହୁଏ, ତେଣୁ କେଉଁ integration call କଲା ଆପଣ ଜାଣିପାରନ୍ତି, access revoke କରିପାରନ୍ତି, ଏବଂ usage attribute କରିପାରନ୍ତି। Scoped tokens ଏହାଠାରୁ ଆଉ ଆଗକୁ ଯାଇ caller କ’ଣ କରିପାରିବେ ତାହା restrict କରନ୍ତି।

Rate limits

Rate limits availability ସୁରକ୍ଷା କରେ। ଏହା ଗୋଟିଏ integration କୁ ସମସ୍ତଙ୍କ ପାଇଁ ଥିବା capacity ଖର୍ଚ୍ଚ କରିବାରୁ ବାରଣ କରେ, ଏବଂ brute-force ଏବଂ enumeration attempts କୁ ଧୀର କରେ। Per-key ଏବଂ per-route limits ଏକ standard, effective control।

ଏକାସାଙ୍ଗେ ଏହି layers protection ଏବଂ accountability ପ୍ରଶ୍ନଗୁଡ଼ିକୁ ବହୁତ ଭଲ ଭାବରେ ଉତ୍ତର ଦେଇଥାଏ। ସେଗୁଡ଼ିକୁ ରଖନ୍ତୁ।

ସେଗୁଡ଼ିକ ଯେ ପ୍ରଶ୍ନର ଉତ୍ତର ପାଇଁ ତିଆରି ହୋଇନଥିଲେ

ସେଇ layers ମଧ୍ୟରୁ କୌଣସିଟି ମଧ୍ୟ authenticated request ର ପଛରେ କେମିତି actor ଅଛି ତାହା କହିବା ପାଇଁ ତିଆରି ହୋଇନଥିଲା। ଏକ valid key କହେ କେଉଁ account integration ର ମାଲିକ। ଏହା କହେନାହିଁ:

ଏହି specific call କି ଆପଣଙ୍କ customer ଙ୍କ app ମଧ୍ୟରେ button ଚାପୁଥିବା ଜଣେ ବ୍ୟକ୍ତିଙ୍କ ଠାରୁ ଆସିଥିଲା,
ଜଣେ ବ୍ୟକ୍ତି AI assistant କୁ action କରିବାକୁ କହିଥିଲେ କି,
ଏକ autonomous agent ଦୀର୍ଘ task ର ଏକ step ଭାବରେ call କଲା କି,
କିମ୍ବା ଏହା ଜାଣିବା ସମ୍ଭବ ନୁହେଁ।

ଏହି ତଫାତ ପ୍ରତି ମାସରେ ଆଉ ଅଧିକ ଗୁରୁତ୍ୱ ନେଉଛି। ଯେ API ଏକ CRM integration, ଗୋଟିଏ scheduling tool କିମ୍ବା ଏକ developer platform serve କରେ, ସେଗୁଡ଼ିକ increasingly ଏକେଇ keys ମାଧ୍ୟମରେ agent traffic ଗ୍ରହଣ କରୁଛି ଯାହା human-driven apps serve କରେ। ଯଦି ଆପଣ agents କୁ structured response ଦେବାକୁ, agents ଦ୍ୱାରା driven high-impact writes ପାଇଁ confirmation ଚାହିବାକୁ, AI-assisted submissions label କରିବାକୁ, କିମ୍ବା କେତେ ଅଂଶ API usage agent-driven ଅଛି ତାହା ମାପିବାକୁ ଚାହାନ୍ତି, ତେବେ actor context ଦରକାର।

Proof of Actor API କୁ କ’ଣ ଯୋଡ଼େ

Proof of Actor ପ୍ରତ୍ୟେକ interaction ପାଇଁ ଚାରିଟି class ମଧ୍ୟରୁ ଗୋଟିଏ ଫେରାଇଦିଏ:

Human: observable signals human-directed interaction ସୂଚିତ କରେ।
Human + AI: ଜଣେ ବ୍ୟକ୍ତି AI assistance ସହିତ interaction କୁ ନିର୍ଦ୍ଦେଶନା କଲେ, ଯାହା supported integration ମାଧ୍ୟମରେ declared କିମ୍ବା observed ହୋଇଥିଲା।
Agent: automated କିମ୍ବା agent-origin interaction.
Unknown: evidence ଏକ reliable determination କୁ support କରେନାହିଁ।

ପ୍ରତ୍ୟେକ result ତାହାର evidence basis ମଧ୍ୟ ଦର୍ଶାଏ:

Verified: ଉଦାହରଣ ସ୍ୱରୂପ, published key ବିରୁଦ୍ଧରେ checked ହୋଇଥିବା HTTP Message Signature (RFC 9421)।
Declared: client କିମ୍ବା ଆପଣଙ୍କ own application ଏହା କହିଥିଲା।
Inferred: behavioral କିମ୍ବା contextual signals, inference ଭାବରେ ସ୍ପଷ୍ଟ ଭାବରେ labeled।
Unknown: କୌଣସି reliable basis ନାହିଁ।

API ପାଇଁ, verified basis ବହୁତ ଉପଯୋଗୀ। ଯେ agents ତାଙ୍କ request sign କରନ୍ତି, ସେଗୁଡ଼ିକୁ ସେମାନଙ୍କ published keys ସହିତ check କରିପାରିବେ, ଯାହା IETF ର Web Bot Auth work ପଛରେ ଥିବା approach। ପୃଷ୍ଠଭୂମି ପାଇଁ product teams ପାଇଁ Web Bot Auth explainer ପଢ଼ନ୍ତୁ, ଏବଂ implementation side ପାଇଁ signed agent requests verify କରିବା guide ପଢ଼ନ୍ତୁ।

ଏଠାରେ ଗୋଟିଏ limit ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ। ଏକ valid signature କେଉଁ key request କୁ sign କଲା ତାହା ପ୍ରମାଣ କରେ। ଏହା agent କାର୍ଯ୍ୟ କରିବାକୁ authorized ଅଛି କି ନୁହେଁ, ତାହା ପ୍ରମାଣ କରେନାହିଁ। Authorization ଆପଣଙ୍କ API ର own access control ମଧ୍ୟରେ ରହିଥାଏ। agent authorization entry ତଫାତଟି ବ୍ୟାଖ୍ୟା କରେ।

Scores ଏବଂ keys ବନାମ actor evidence

କିଛି bot protection products ପ୍ରତ୍ୟେକ request ସହିତ score ଯୋଡ଼ନ୍ତି। Block decision ପାଇଁ score କାର୍ଯ୍ୟକାରୀ। କିନ୍ତୁ API product decisions ପାଇଁ ଏହା କମ୍ ଉପଯୋଗୀ, କାରଣ ଏହା କହେନାହିଁ ଯେ legitimate request human-driven ଥିଲା କି agent-driven, ଏବଂ verified facts କୁ inference ଠାରୁ ପୃଥକ କରେନାହିଁ।

API keys ରେ ଏହାର ବିପରୀତ limit ଅଛି। ସେଗୁଡ଼ିକ ownership ପାଇଁ precise, କିନ୍ତୁ actor ବିଷୟରେ ନିରବ। ଗୋଟିଏ customer ର key ଗୋଟିଏ ଘଣ୍ଟାରେ ଚାରିଟି class ର ସବୁକୁ ବହନ କରିପାରେ।

Proof of Actor ଦୁଇଟି ତଫାତକୁ visible ରଖେ। ଆପଣଙ୍କ API key ର account, Proof of Actor ର actor class, ଏବଂ ତାହାକୁ support କରୁଥିବା basis ଦେଖେ। ପ୍ରତ୍ୟେକ layer ଯେ ପ୍ରଶ୍ନରେ ଭଲ, ସେହି ପ୍ରଶ୍ନର ଉତ୍ତର ଦେଏ।

ପ୍ରତ୍ୟେକଟି କେଉଁଠି run କରେ

Gateway ଏବଂ WAF ଆପଣଙ୍କ network ର edge ରେ କିମ୍ବା services ର ସମ୍ମୁଖରେ run କରନ୍ତି। ସେ position protection ଏବଂ quotas ପାଇଁ ସଠିକ।

Proof of Actor ଯେଉଁଠାରେ ଆପଣଙ୍କ API logic ରହେ ସେଠାରେ run କରେ। Founding teams Node.js middleware, Next.js, ଆପଣ control କରୁଥିବା ଏକ edge layer, generic HTTP API, କିମ୍ବା ଏକ MCP server integration ମାଧ୍ୟମରେ integrate କରିପାରିବେ। ସମ୍ପୂର୍ଣ୍ଣ list ପାଇଁ integrations ଦେଖନ୍ତୁ। ଏହା ଆପଣଙ୍କ application ମଧ୍ୟରେ run କରୁଥିବାରୁ, ଏହା ଆପଣଙ୍କ API ଯାହା ଜାଣେ ତାହା ବ୍ୟବହାର କରିପାରେ: route, workflow, client ନିଜକୁ declared କଲା କି ନାହିଁ, ଏବଂ signature verified ହେଲା କି ନାହିଁ।

Routing decisions ଆପଣଙ୍କ code ମଧ୍ୟରେ ରହିଥାଏ

Proof of Actor default ଭାବରେ କିଛି block କରେନାହିଁ। ଏହା observation mode ରେ ଆରମ୍ଭ ହୁଏ, ତେଣୁ ଏହା install କଲେ ଆପଣଙ୍କ API response ରେ କିଛି ବଦଳାଏନାହିଁ। ଆପଣ endpoint ଅନୁସାରେ actor mix ଦେଖନ୍ତି, individual results ପାଇଁ evidence review କରନ୍ତି, ଏବଂ ନିଜ Unknown rate ଟିକୁ ନଜର ରଖନ୍ତି।

ଆପଣ ready ହେଲେ, route, actor class ଏବଂ basis ଅନୁସାରେ application-defined policies ଲେଖନ୍ତି। ସାଧାରଣ outcomes ହେଲା:

Allow: request କୁ ସାଧାରଣ ଭାବରେ serve କରନ୍ତୁ।
Adapt: verified agent ପାଇଁ structured କିମ୍ବା reduced response ଫେରାନ୍ତୁ।
Challenge: ଗୋଟିଏ extra confirmation step ଆବଶ୍ୟକ କରନ୍ତୁ, ଉଦାହରଣ ସ୍ୱରୂପ high-impact write ପାଇଁ human approval।
Review: action କୁ ଜଣେ ବ୍ୟକ୍ତି check କରିବା ପାଇଁ queue କରନ୍ତୁ।
Rate-limit: ଗୋଟିଏ specific route ଉପରେ specific class ଏବଂ basis ପାଇଁ ଅଧିକ କଠିନ limit ପ୍ରୟୋଗ କରନ୍ତୁ।

ଆପଣ policy କୁ real traffic ଉପରେ enforce କରିବା ପୂର୍ବରୁ preview କରିପାରନ୍ତି, ତାପରେ route by route enforce କରିପାରନ୍ତି। actor-aware policies safely roll out କରିବା guide ପ୍ରକ୍ରିୟାକୁ କଭର୍ କରେ, ଏବଂ agents କୁ block କରିବା ବିନା sensitive actions ସୁରକ୍ଷା କରିବା ସାଧାରଣ patterns ଦେଖାଏ।

Unknown API callers କୁ handle କରିବା

ପ୍ରତ୍ୟେକ API କିଛି traffic ଗ୍ରହଣ କରେ ଯାହାକୁ confidence ସହିତ classify କରିହେବ ନାହିଁ। Traditional controls ସହିତ, valid key ସାଧାରଣତଃ request କୁ ପାର୍ ହେବାକୁ ଦିଏ, ଏବଂ invalid key ସେହି କାମ କରେନାହିଁ। ମଧ୍ୟସ୍ଥ ସ୍ଥାନରେ କିଛି ନଥାଏ।

Proof of Actor ଆପଣଙ୍କୁ explicit Unknown result ଦିଏ ଏବଂ route ଅନୁସାରେ fallback ବାଛିବାକୁ ଦେଏ। Read-only catalog endpoints open ରହିପାରେ। Account changes ଆପଣଙ୍କ existing stricter checks ରଖିପାରେ। Bulk exports review କୁ ଯାଇପାରେ। Details ପାଇଁ Unknown traffic handle କରିବା ଏବଂ unknown automated traffic ଦେଖନ୍ତୁ।

ସେମାନେ କିପରି combine ହୁଅନ୍ତି

ସବୁଠାରୁ ଶକ୍ତିଶାଳୀ API setup ପ୍ରତ୍ୟେକ layer କୁ ତାହାର own job ପାଇଁ ବ୍ୟବହାର କରେ:

Edge ରେ, WAF abusive ଏବଂ malformed traffic filter କରେ।
Gateway ରେ, keys authenticate ହୁଏ, quotas enforce ହୁଏ ଏବଂ usage record କରାଯାଏ।
API ମଧ୍ୟରେ, Proof of Actor ପାର୍ ହୋଇଆସୁଥିବା ପ୍ରତ୍ୟେକ request କୁ classify କରେ ଏବଂ ତାହାର basis କହେ।
ଆପଣଙ୍କ handlers ମଧ୍ୟରେ, policies class ଏବଂ basis ବ୍ୟବହାର କରି response ବାଛନ୍ତି: human-driven call ପାଇଁ normal handling, verified agent ପାଇଁ structured response, agent-driven high-impact write ପାଇଁ confirmation step, Unknown ପାଇଁ fallback.
Analytics ରେ, ଆପଣଙ୍କ team gateway ରୁ account data ସହିତ କେଉଁ endpoints ଏବଂ workflows ପ୍ରତ୍ୟେକ actor class ବ୍ୟବହାର କରୁଛି ଦେଖେ।

ଏହି stack ରେ କିଛିମଧ୍ୟ duplicated ନୁହେଁ। Gateway account କୁ ଜାଣେ, WAF threat patterns କୁ ଜାଣେ, ଏବଂ Proof of Actor actor କୁ ଜାଣେ।

କେବେ କେଉଁଥିରେ focus କରିବେ

ଆପଣଙ୍କ main problems abuse, availability କିମ୍ବା unmetered usage ହେଲେ, ପ୍ରଥମେ API bot protection ଉପରେ focus କରନ୍ତୁ: auth endpoints ବିରୁଦ୍ଧରେ credential attacks, aggressive scraping, କିମ୍ବା ଗୋଟିଏ integration ଦ୍ୱାରା ଅନ୍ୟମାନଙ୍କୁ starve କରାଯିବା।

ଆପଣଙ୍କ main questions ଯଦି callers ସମ୍ପର୍କରେ ଅଛି, ତେବେ Proof of Actor ଉପରେ focus କରନ୍ତୁ: କେତେ ପରିମାଣର API traffic agent-driven, କେଉଁ agents କେଉଁ endpoints call କରୁଛନ୍ତି, human-driven ଏବଂ agent-driven usage କେଉଁଠି ଭିନ୍ନ, ଏବଂ କେଉଁ routes actor-aware policy ଦରକାର। APIs use case ଏବଂ AI agent identification for APIs ଆଉ ଗଭୀରରେ ଯାଏ।

Production API ଚଲାଉଥିବା ଅଧିକାଂଶ teams କୁ ଦୁଇଟିର ଉତ୍ତର ଦରକାର।

ଆରମ୍ଭ କରନ୍ତୁ

Proof of Actor private beta ରେ ଅଛି। ଚୟନିତ founding developer teams agreed usage limits ମଧ୍ୟରେ up to 12 months of free access ପାଇପାରିବେ, automatic billing ବିନା। early access ପାଇଁ apply କରନ୍ତୁ ଏବଂ ଆପଣ ବୁଝିବାକୁ ଚାହୁଥିବା API ଏବଂ callers ବିଷୟରେ ଆମକୁ କହନ୍ତୁ।

ବିକାଶକର୍ତ୍ତାମାନଙ୍କ ପାଇଁ

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 ପଛରେ ଥିବା signal, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ team କାହିଁକି ତାହା ଦେଖିପାରିବ।

observation mode ରେ ଆରମ୍ଭ କରନ୍ତୁ: ଆପଣଙ୍କ log ପାଖରେ result record କରନ୍ତୁ ଏବଂ ଆପଣ policy ବାଛିବା ପର୍ଯ୍ୟନ୍ତ କିଛି ମଧ୍ୟ ପରିବର୍ତ୍ତନ କରନ୍ତୁ ନାହିଁ। Node.js integration guide ପଢନ୍ତୁ

ସାଧାରଣ ପ୍ରଶ୍ନଗୁଡ଼ିକ

Proof of Actor କି ମୋର API gateway କିମ୍ବା WAF କୁ replace କରେ?

ନା। ଆପଣଙ୍କ gateway ତଥାପି keys authenticate କରେ ଏବଂ quotas enforce କରେ, ଏବଂ ଆପଣଙ୍କ WAF ତଥାପି abusive traffic filter କରେ। Proof of Actor ଆପଣଙ୍କ API ମଧ୍ୟରେ run କରେ ଏବଂ ଯେ request ଗୁଡ଼ିକ ପାର୍ ହୋଇଆସେ ସେଗୁଡ଼ିକୁ actor context ଯୋଡ଼େ। ଆପଣଙ୍କ ପୂର୍ବବର୍ତ୍ତୀ controls କୁ ରଖନ୍ତୁ।

ଯଦି ପ୍ରତ୍ୟେକ caller ପାଖରେ API key ଅଛି, ତେବେ ମୋତେ actor context କାହିଁକି ଦରକାର?

ଏକ API key ସେହି account କୁ ଚିହ୍ନଟ କରେ ଯାହା integration ର ମାଲିକ। ଏହା କହେନାହିଁ ଯେ ନିର୍ଦ୍ଦିଷ୍ଟ request କି ଆପଣଙ୍କ customer ଙ୍କ app ଭିତରେ click କରୁଥିବା ଜଣେ ବ୍ୟକ୍ତିଙ୍କ ଠାରୁ, AI assistant ବ୍ୟବହାର କରୁଥିବା ଜଣେ ବ୍ୟକ୍ତିଙ୍କ ଠାରୁ, କିମ୍ବା ଏକ task ଚଲାଉଥିବା autonomous agent ଠାରୁ ଆସିଥିଲା। Proof of Actor ଏହାକୁ ତାହାର basis ସହିତ report କରେ।

Proof of Actor କି ମୋର API କୁ call କରୁଥିବା କେଉଁ agent ତାହା verify କରିପାରେ?

ଯେତେବେଳେ ଜଣେ client ତାହାର request ଗୁଡ଼ିକୁ HTTP Message Signatures (RFC 9421) ସହିତ sign କରେ ଏବଂ ତାହାର key publish କରେ, Proof of Actor signature କୁ check କରେ ଏବଂ verified basis report କରେ। ଏକ valid signature କେଉଁ key request କୁ sign କଲା ତାହା ପ୍ରମାଣ କରେ। ଏହା agent କାର୍ଯ୍ୟ କରିବାକୁ authorized କି ନୁହେଁ, ତାହା ପ୍ରମାଣ କରେନାହିଁ, ତେଣୁ authorization ଆପଣଙ୍କ code ମଧ୍ୟରେ ରହିଥାଏ।

Proof of Actor କି ମୋର API traffic କୁ rate-limit କିମ୍ବା block କରିବା ଆରମ୍ଭ କରିବ?

ନା। ଏହା observation mode ରେ ଆରମ୍ଭ ହୁଏ ଏବଂ default ଭାବରେ କିଛି block କରେନାହିଁ। Rate-limit ହେଉଛି ଏକ outcome ଯାହା ଆପଣ policy ମଧ୍ୟରେ ବାଛିପାରିବେ, per route, actor class ଏବଂ basis ଅନୁସାରେ, ଏବଂ enforcement ଆପଣଙ୍କ own code ଭିତରେ ରହିଥାଏ।

ମୁଁ API ରେ Proof of Actor କିପରି add କରିବି?

Founding teams Node.js middleware, Next.js, ଏକ edge integration କିମ୍ବା generic HTTP API ବ୍ୟବହାର କରିପାରନ୍ତି। MCP servers ଙ୍କ ପାଇଁ ନିଜସ୍ୱ integration ଅଛି। Details ପାଇଁ integrations page ଦେଖନ୍ତୁ।

ଯେ callers କୁ ଆପଣ classify କରିପାରୁନାହାନ୍ତି, ସେମାନଙ୍କ ସହିତ କଣ ହୁଏ?

ସେଗୁଡ଼ିକୁ Unknown ଭାବରେ report କରାଯାଏ, ଏହା ଏକ first-class result। ଆପଣ route ଅନୁସାରେ fallback ବାଛନ୍ତି, ଉଦାହରଣ ସ୍ୱରୂପ read-only endpoints ରେ allow କରନ୍ତୁ ଏବଂ write endpoints ରେ ଆପଣଙ୍କ ଅଧିକ କଠିନ checks ରଖନ୍ତୁ।

ଆପଣଙ୍କ app କୁ କିଏ ବ୍ୟବହାର କରୁଛି, ତାହା ଜାଣନ୍ତୁ।

Founding developer ଙ୍କ ଛୋଟ ଦଳ ପାଇଁ private beta।

Early Access ପାଆନ୍ତୁ ମୂଲ୍ୟ ଦେଖନ୍ତୁ

ପ୍ରଥମେ କଥାହେବାକୁ ପସନ୍ଦ କରନ୍ତି? founderମାନଙ୍କ ସହ କଥାବାର୍ତ୍ତା କରନ୍ତୁ