పోలిక

Proof of Actor vs API bot protection: keys చెబుతాయి ఎవరు చెల్లిస్తున్నారు, actor context చెబుతుంది ఎవరు చర్య తీసుకుంటున్నారు

API gatewayలు, WAF bot rules, API keys మరియు rate limits మీ API ను అందుబాటులో ఉంచి, బాధ్యతను నిర్ధారిస్తాయి. ఇవి ఒక request యాప్‌లోని వ్యక్తి నుండి వచ్చిందా, assistant తో పనిచేస్తున్న వ్యక్తి నుండి వచ్చిందా, లేక autonomous agent నుండి వచ్చిందా అని చెప్పడానికి తయారు కాలేదు. APIల కోసం bot management ను Proof of Actor తో ఎలా పోల్చాలో, మరియు ఈ రెండూ కలిసి ఎలా పనిచేస్తాయో ఇక్కడ చూడండి.

తొందరగా యాక్సెస్ పొందండి ఇది ఎలా పనిచేస్తుందో అన్వేషించండి

రచన Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

చిన్న సమాధానం

APIల కోసం bot management మీ endpoints ను రక్షిస్తుంది: gatewayలు keys ను authenticate చేస్తాయి, WAF bot rules దుర్వినియోగ traffic ను filter చేస్తాయి, rate limits volume ను పరిమితం చేస్తాయి. Proof of Actor వేరొక layer ను జోడిస్తుంది, ప్రతి caller Human, Human + AI, Agent లేదా Unknown లో ఏదో మీ API కు చెబుతుంది, దానికి ఉన్న evidence తో పాటు, తద్వారా మీ code ప్రతి ఒక్కరికి సరైన విధంగా సేవ చేయగలదు. ఎక్కువ teams రెండింటినీ నడుపుతాయి.

APIలకు ఒకప్పుడు సరళమైన traffic model ఉండేది. ఒక developer నమోదు చేసుకుని, ఒక key పొందేవాడు, ఒక integration రాసేవాడు, ఆ integration షెడ్యూల్ ప్రకారం లేదా user ఏదైనా క్లిక్ చేసినప్పుడు మీ endpoints ను పిలిచేది. APIల కోసం bot management ఆ model చుట్టూ ఎదిగింది: key ను authenticate చేయండి, volume ను పరిమితం చేయండి, స్పష్టంగా దుర్వినియోగమైన traffic ను filter చేయండి, మరియు service ను మిగతా అందరికీ అందుబాటులో ఉంచండి.

ఆ model ఇప్పటికీ వర్తిస్తుంది, మరియు దానికోసం నిర్మించిన tools ఇప్పటికీ ముఖ్యమే. మారింది calls వెనుక ఎవరు ఉన్నారనేదే. అదే API key ఇప్పుడు మీ customer's app ను ఉపయోగిస్తున్న వ్యక్తి నుండి, పని చేయమని AI assistant ను అడిగిన వ్యక్తి నుండి, మరియు రాత్రంతా multi-step task ను నడుపుతున్న autonomous agent నుండి requests ను మోసుకొస్తుంది. మీ existing controls ఒక key ను మరియు ఒక request rate ను మాత్రమే చూస్తాయి. మీ product, support మరియు policy నిర్ణయాలకు తరచుగా మరింత సమాచారం అవసరం.

Proof of Actor ఆ ఖాళీని పూరిస్తుంది. ఇది మీ API కు ప్రతి request పై ఎవరు లేదా ఏమి చర్య తీసుకుంటున్నారో చెబుతుంది, evidence ను పేర్కొంటుంది, ఆపై నిర్ణయాన్ని మీ code కు వదిలేస్తుంది. ఈ page ప్రతి layer ఎక్కడ సరిపోతుందో చూడటానికి ప్రధాన API bot protection layers తో దానిని పోల్చుతుంది.

The short version

	API bot protection	Proof of Actor
Main question	ఈ request అనుమతించబడిందా, authenticated అయిందా, మరియు limits లో ఉందా?	ఎవరు లేదా ఏమి చర్య తీసుకుంటున్నారు, మరియు evidence ఏమిటి?
Typical layers	API gateway, WAF bot rules, API keys, rate limits	మీ API లేదా MCP server లో actor classification
Identifies	Key ను కలిగి ఉన్న account లేదా integration	ప్రతి request వెనుక ఉన్న actor: Human, Human + AI, Agent లేదా Unknown
Output	Allow, reject, throttle; కొన్ని సార్లు bot score	ఒక class తో పాటు basis: verified, declared, inferred లేదా unknown
Unclear traffic	సాధారణంగా key valid అయితే allow చేస్తారు, లేదా rule ద్వారా reject చేస్తారు	Unknown, మీరు route వారీగా ఎంచుకునే fallback తో
Who decides the response	Gateway మరియు WAF configuration	మీ application code
Default on install	Enforcement	Observation; మీరు policy జోడించే వరకు ఏదీ మారదు
Best at	Availability, abuse filtering, quotas, accountability	ప్రతి actor కు సరైన సేవ అందించడం మరియు API usage ను అర్థం చేసుకోవడం

కింద ఉన్న sections ప్రతి భాగాన్ని వివరించాయి.

What API bot protection does well

ప్రతి layer చేసే పని గురించి స్పష్టంగా ఉండటం విలువైనది, ఎందుకంటే Proof of Actor వాటన్నిటి పక్కన నిలవడానికి రూపొందించబడింది, వాటిలో దేనినీ భర్తీ చేయడానికి కాదు.

API gateways

Gateway మీ API కి ముందువైపు ద్వారం. ఇది connections ను ముగిస్తుంది, API keys లేదా tokens ను authenticate చేస్తుంది, requests ను సరైన service కు route చేస్తుంది, quotas ను అమలు చేస్తుంది, మరియు తరచుగా billing మరియు analytics కోసం usage ను record చేస్తుంది. ఇది "ఈ caller లోపలికి రావచ్చా, మరియు ఏ ద్వారం ద్వారా?" అనే ప్రశ్నకు ప్రతి endpoint లో వేగంగా మరియు స్థిరంగా సమాధానం ఇస్తుంది.

WAF bot rules

Bot rules ఉన్న web application firewall known attack patterns మరియు దుర్వినియోగ automation కోసం traffic ను పరిశీలిస్తుంది. ఇది injection ప్రయత్నాలను filter చేయగలదు, abuse చరిత్ర ఉన్న sources నుండి traffic ను block చేయగలదు, మరియు scraping లేదా credential attacks లాగా కనిపించే requests ను challenge చేయగలదు లేదా drop చేయగలదు. మీ code వరకు ఎప్పుడూ చేరకూడని traffic కు ఇది మీ ఉత్తమ రక్షణ.

API keys and tokens

Keys మరియు tokens మీకు accountability ఇస్తాయి. ప్రతి request ఒక account కు map అవుతుంది, కాబట్టి ఏ integration call చేసిందో మీకు తెలుస్తుంది, access ను revoke చేయగలరు, మరియు usage ను attribute చేయగలరు. Scoped tokens మరింత ముందుకు వెళ్లి caller ఏమి చేయగలడో పరిమితం చేస్తాయి.

Rate limits

Rate limits availability ను రక్షిస్తాయి. అవి ఒక integration అందరికీ ఉద్దేశించిన capacity ను వినియోగించకుండా ఆపుతాయి, మరియు brute-force మరియు enumeration ప్రయత్నాలను నెమ్మదింపజేస్తాయి. ప్రతి key మరియు ప్రతి route కు limits ఒక ప్రామాణికమైన, ప్రభావవంతమైన control.

కలిపి, ఈ layers protection మరియు accountability ప్రశ్నలకు చాలా బాగా సమాధానం ఇస్తాయి. వాటిని ఉంచండి.

The question they were not built to answer

ఆ layers లో ఏదీ authenticated request వెనుక ఏ రకమైన actor ఉందో చెప్పడానికి రూపొందించబడలేదు. ఒక valid key ఏ account integration ను కలిగి ఉందో చెబుతుంది. అది ఇవి చెప్పదు:

ఈ specific call మీ customer's app లో button ను tap చేసిన వ్యక్తి నుండి వచ్చిందా,
ఈ చర్యను చేయమని ఒక వ్యక్తి AI assistant ను అడిగాడా,
autonomous agent దీన్ని పెద్ద task లో ఒక step గా చేసిందా,
లేదా ఎవరికీ తెలియదా.

ఆ తేడా ప్రతి నెలా మరింత ముఖ్యమవుతోంది. CRM integration, scheduling tool లేదా developer platform ను సేవ చేసే API increasingly అదే keys ద్వారా వచ్చే agent traffic ను స్వీకరిస్తోంది, అవే keys human-driven apps ను కూడా సేవిస్తాయి. మీరు agents కు structured response ఇవ్వాలనుకుంటే, agents నడిపే high-impact writes కోసం confirmation కోరాలనుకుంటే, AI-assisted submissions ను label చేయాలనుకుంటే, లేదా మీ API usage లో ఎంత భాగం agent-driven అనేది కొలవాలనుకుంటే, actor context అవసరం.

What Proof of Actor adds to an API

Proof of Actor ప్రతి interaction కు నాలుగు classes లో ఒకటిని ఇస్తుంది:

Human: observable signals human-directed interaction ను సూచిస్తాయి.
Human + AI: ఒక వ్యక్తి AI assistance తో interaction ను నడిపాడు, అది ఒక supported integration ద్వారా declared అయ్యింది లేదా observed అయ్యింది.
Agent: automated లేదా agent-origin interaction.
Unknown: evidence నమ్మదగిన నిర్ణయాన్ని మద్దతు ఇవ్వదు.

ప్రతి result దాని evidence basis ను కూడా తెలియజేస్తుంది:

Verified: ఉదాహరణకు, published key పై తనిఖీ చేసిన HTTP Message Signature (RFC 9421).
Declared: client లేదా మీ own application అది తెలిపింది.
Inferred: behavioral లేదా contextual signals, inference గా స్పష్టంగా label చేయబడినవి.
Unknown: నమ్మదగిన basis లేదు.

APIల కోసం, verified basis ప్రత్యేకంగా ఉపయోగకరం. తమ requests ను sign చేసే agents ను వారి published keys తో తనిఖీ చేయవచ్చు, ఇదే IETF Web Bot Auth పని వెనుక ఉన్న approach. నేపథ్యం కోసం Web Bot Auth for product teams explainer చదవండి, మరియు implementation వైపు కోసం verifying signed agent requests guide చూడండి.

ఇక్కడ ఒక పరిమితి ముఖ్యం. Valid signature ఏ key request ను sign చేసిందో రుజువు చేస్తుంది. ఆ agent చర్య చేయడానికి అధికారం ఉందని అది రుజువు చేయదు. Authorization దాని స్థానం అయిన మీ API యొక్క own access control లోనే ఉంటుంది. agent authorization entry తేడాను వివరిస్తుంది.

Scores and keys versus actor evidence

కొన్ని bot protection products ప్రతి request కు ఒక score ను జత చేస్తాయి. Block decision కోసం score సమర్థవంతం. కానీ API product నిర్ణయాల కోసం అది తక్కువ ఉపయోగకరం, ఎందుకంటే అది legitimate request human-driven అయిందా agent-driven అయిందా చెప్పదు, మరియు verified facts ను inference నుండి వేరు చేయదు.

API keys కు వ్యతిరేక పరిమితి ఉంది. అవి ownership గురించి ఖచ్చితమైనవి, కానీ actor గురించి మౌనం. ఒక customer యొక్క key ఒకే గంటలో నాలుగు classes అన్నింటినీ మోసుకురాగలదు.

Proof of Actor ఈ రెండు distinctions ను కనిపించేలా ఉంచుతుంది. మీ API key నుండి account ను చూస్తుంది, Proof of Actor నుండి actor class ను చూస్తుంది, మరియు దాన్ని మద్దతు ఇచ్చే basis ను చూస్తుంది. ప్రతి layer తాను బాగా చేయగల ప్రశ్నకు సమాధానం ఇస్తుంది.

Where each one runs

Gateways మరియు WAFs మీ network edge లో లేదా మీ services ముందు నడుస్తాయి. ఆ స్థానం protection మరియు quotas కోసం సరైనది.

Proof of Actor మీ API logic ఉన్న చోట నడుస్తుంది. Founding teams Node.js middleware, Next.js, మీరు నియంత్రించే ఒక edge layer, generic HTTP API, లేదా MCP server integration ద్వారా integrate చేయగలరు. పూర్తి జాబితా కోసం integrations చూడండి. ఇది మీ application లోపల నడిచే కారణంగా, మీ API కు తెలిసిన విషయాలను ఉపయోగించగలదు: route, workflow, client తనను తాను declared చేసుకుందా, మరియు signature verify అయ్యిందా.

Routing decisions stay in your code

Proof of Actor by default ఏదీ block చేయదు. ఇది observation mode లో ప్రారంభమవుతుంది, కాబట్టి దానిని install చేయడం వల్ల మీ API ఎలా respond అవుతుందో మారదు. మీరు endpoint వారీగా మీ actor mix ను చూస్తారు, individual results కోసం evidence ను review చేస్తారు, మరియు మీ Unknown rate ను గమనిస్తారు.

మీరు సిద్ధంగా ఉన్నప్పుడు, ప్రతి route, ప్రతి actor class, మరియు ప్రతి basis కు application-defined policies ను రాస్తారు. సాధారణ outcomes ఇవి:

Allow: request ను సాధారణంగా serve చేయండి.
Adapt: verified agent కోసం structured లేదా reduced response ను తిరిగి ఇవ్వండి.
Challenge: అదనపు confirmation step ను అవసరం చేయండి, ఉదాహరణకు high-impact write పై human approval.
Review: action ను ఒక వ్యక్తి తనిఖీ చేయడానికి queue చేయండి.
Rate-limit: నిర్దిష్ట route పై నిర్దిష్ట class మరియు basis కు మరింత కఠినమైన limit ను వర్తించండి.

మీరు policy ను real traffic పై enforce చేసే ముందు preview చేయవచ్చు, ఆపై route by route గా enforce చేయవచ్చు. rolling out actor-aware policies safely guide ఈ ప్రక్రియను కవర్ చేస్తుంది, మరియు protecting sensitive actions without blocking agents సాధారణ patterns ను చూపిస్తుంది.

Handling Unknown API callers

ప్రతి API confidence తో classify చేయలేని traffic ను స్వీకరిస్తుంది. Traditional controls తో, valid key అంటే సాధారణంగా request గుండా వెళ్తుంది, invalid key అంటే వెళ్ళదు. మధ్యలో ఏమీ లేదు.

Proof of Actor స్పష్టమైన Unknown result ను ఇస్తుంది మరియు route వారీగా fallback ను ఎంచుకోవడానికి అనుమతిస్తుంది. Read-only catalog endpoints ఓపెన్ గా ఉండవచ్చు. Account changes మీ existing stricter checks ను కొనసాగించవచ్చు. Bulk exports review కు వెళ్లవచ్చు. వివరాల కోసం handling Unknown traffic మరియు unknown automated traffic చూడండి.

How they combine

అత్యంత బలమైన API setup ప్రతి layer ను దాని own job కోసం ఉపయోగిస్తుంది:

At the edge, WAF దుర్వినియోగ మరియు తప్పుగా రూపొందించిన traffic ను filter చేస్తుంది.
At the gateway, keys authenticate చేయబడతాయి, quotas అమలు చేయబడతాయి, మరియు usage record చేయబడుతుంది.
Inside the API, Proof of Actor గుండా వచ్చిన ప్రతి request ను classify చేస్తుంది మరియు దాని basis ను తెలియజేస్తుంది.
In your handlers, policies class మరియు basis ను ఉపయోగించి response ను ఎంచుకుంటాయి: human-driven call కు normal handling, verified agent కు structured response, agent-driven high-impact write కు confirmation step, Unknown కు fallback.
In analytics, మీ team gateway నుండి వచ్చిన account data తో పాటు, ప్రతి actor class ఏ endpoints మరియు workflows ను ఉపయోగిస్తుందో చూస్తుంది.

ఈ stack లో ఏదీ duplicate కాదు. Gateway account ను తెలుసుకుంటుంది, WAF threat patterns ను తెలుసుకుంటుంది, మరియు Proof of Actor actor ను తెలుసుకుంటుంది.

When to focus on which

మీ ప్రధాన సమస్యలు abuse, availability లేదా unmetered usage అయితే ముందు API bot protection పై దృష్టి పెట్టండి: auth endpoints పై credential attacks, aggressive scraping, లేదా ఒక integration ఇతరులను starve చేయడం.

మీ ప్రధాన ప్రశ్నలు callers గురించి అయితే Proof of Actor పై దృష్టి పెట్టండి: మీ API traffic లో ఎంత భాగం agent-driven గా ఉంది, ఏ agents ఏ endpoints ను పిలుస్తున్నాయి, human-driven మరియు agent-driven usage ఎక్కడ భిన్నంగా ఉంది, మరియు ఏ routes కు actor-aware policy అవసరం. APIs use case మరియు AI agent identification for APIs మరింత లోతుగా వెళ్తాయి.

Production API నడిపే ఎక్కువ teams కు రెండింటికీ సమాధానాలు అవసరం.

Get started

Proof of Actor private beta లో ఉంది. ఎంచుకున్న founding developer teams ఒప్పుకున్న usage limits లో, automatic billing లేకుండా, 12 months వరకు free access పొందగలరు. Apply for early access చేసి, మీరు అర్థం చేసుకోవాలనుకునే 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: evidence ఎంత బలంగా ఉందో: verified, declared, inferred లేదా unknown.
evidence: result వెనుక ఉన్న signals, అందువల్ల మీ team ఎందుకు అని చూడగలదు.

observation mode లో ప్రారంభించండి: results ను మీ logs పక్కనే నమోదు చేయండి మరియు మీరు ఒక policy ఎంచుకునే వరకు ఏమీ మార్చవద్దు. Node.js integration guide ను చదవండి

తరచుగా అడిగే ప్రశ్నలు

Proof of Actor నా API gateway లేదా WAF ను భర్తీ చేస్తుందా?

లేదు. మీ gateway ఇంకా keys ను authenticate చేసి quotas ను అమలు చేస్తుంది, మీ WAF ఇంకా దుర్వినియోగ traffic ను filter చేస్తుంది. Proof of Actor మీ API లోపల నడుస్తుంది మరియు గుండా వచ్చిన requests కు actor context ను జత చేస్తుంది. మీ existing controls ను అలాగే ఉంచండి.

ప్రతి caller దగ్గర API key ఉంటే, నాకు actor context ఎందుకు కావాలి?

API key integration ను కలిగి 있는 account ను గుర్తిస్తుంది. కానీ ఏ request అనేది customer app లో క్లిక్ చేస్తున్న వ్యక్తి ద్వారా నడిచిందో, AI assistant ను ఉపయోగిస్తున్న వ్యక్తి ద్వారా నడిచిందో, లేదా task ను అమలు చేస్తున్న autonomous agent ద్వారా నడిచిందో అది చెప్పదు. Proof of Actor దాన్ని, దాని basis తో పాటు, నివేదిస్తుంది.

నా API ని ఏ agent పిలుస్తోందో Proof of Actor verify చేయగలదా?

ఒక client తన requests ను HTTP Message Signatures (RFC 9421) తో sign చేసి తన key ను publish చేస్తే, Proof of Actor signature ను తనిఖీ చేసి verified basis ను నివేదిస్తుంది. Valid signature ఏ key request ను sign చేసిందో చూపిస్తుంది. కానీ ఆ agent కు action చేయడానికి అధికారం ఉందని అది రుజువు చేయదు, కాబట్టి authorization మీ code లోనే ఉంటుంది.

Proof of Actor నా API traffic పై rate-limiting లేదా blocking ప్రారంభిస్తుందా?

లేదు. ఇది observation mode లో ప్రారంభమవుతుంది మరియు by default ఏదీ block చేయదు. Rate-limit అనేది మీరు policy లో ఎంచుకోగల outcome, route, actor class మరియు basis ప్రకారం, మరియు enforcement మీ own code లో ఉంటుంది.

API కు Proof of Actor ను ఎలా జోడించాలి?

Founding teams Node.js middleware, Next.js, ఒక edge integration లేదా generic HTTP API ను ఉపయోగించగలరు. MCP servers కు తమ own integration ఉంది. వివరాల కోసం integrations page చూడండి.

నేను classify చేయలేని callers కు ఏమవుతుంది?

వారు Unknown గా report చేయబడతారు, ఇది first-class result. మీరు route వారీగా fallback ను ఎంచుకుంటారు, ఉదాహరణకు read-only endpoints లో allow చేయడం, మరియు write endpoints లో మీ stricter checks ను కొనసాగించడం.

మీ app ను ఎవరు ఉపయోగిస్తున్నారో తెలుసుకోండి.

founding developers యొక్క చిన్న group కోసం private beta.

తొందరగా యాక్సెస్ పొందండి ధరలను చూడండి

ముందుగా మాట్లాడాలనుకుంటున్నారా? foundersతో మాట్లాడండి