ಹೋಲಿಕೆ

Proof of Actor vs API ಬಾಟ್ ರಕ್ಷಣೆ: keys ಯಾರು ಪಾವತಿಸುತ್ತಾರೆ ಎಂದು ಹೇಳುತ್ತವೆ, actor context ಯಾರು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದಾರೆ ಎಂದು ಹೇಳುತ್ತದೆ

API gateways, WAF bot rules, API keys and rate limits ನಿಮ್ಮ API ಅನ್ನು ಲಭ್ಯವಾಗಿಯೂ ಹೊಣೆಗಾರವಾಗಿಯೂ ಇಡುತ್ತವೆ. ಆದರೆ ಒಂದು request ಆ್ಯಪ್‌ನಲ್ಲಿರುವ ವ್ಯಕ್ತಿಯಿಂದ, assistant ಜೊತೆ ಕೆಲಸ ಮಾಡುವ ವ್ಯಕ್ತಿಯಿಂದ, ಅಥವಾ autonomous agent ನಿಂದ ಬಂದಿತೇ ಎಂಬುದನ್ನು ಹೇಳಲು ಅವುಗಳನ್ನು ನಿರ್ಮಿಸಲಾಗಿಲ್ಲ. API ಗಳಿಗಾಗಿ ಬಾಟ್ ನಿರ್ವಹಣೆ Proof of Actor ನೊಂದಿಗೆ ಹೇಗೆ ಹೋಲುತ್ತದೆ, ಮತ್ತು ಈ ಎರಡೂ ಹೇಗೆ ಒಟ್ಟಿಗೆ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದು ಇಲ್ಲಿದೆ.

ಮುಂಗಡ ಪ್ರವೇಶ ಪಡೆಯಿರಿ ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸಿ

ರಚನೆ Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ಸಂಕ್ಷಿಪ್ತ ಉತ್ತರ

API ಗಳಿಗಾಗಿ ಬಾಟ್ ನಿರ್ವಹಣೆ ನಿಮ್ಮ endpoints ಗಳನ್ನು ರಕ್ಷಿಸುತ್ತದೆ: gateways keys ಗಳನ್ನು authenticate ಮಾಡುತ್ತವೆ, WAF bot rules ದುರುಪಯೋಗದ traffic ಅನ್ನು ಶೋಧಿಸುತ್ತವೆ, ಮತ್ತು rate limits ಪ್ರಮಾಣವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತವೆ. Proof of Actor ಬೇರೆ layer ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ನಿಮ್ಮ API ಗೆ ಪ್ರತಿಯೊಂದು caller Human, Human + AI, Agent ಅಥವಾ Unknown ಎಂದು ಮತ್ತು ಅದರ ಹಿಂದೆ ಇರುವ evidence ನೊಂದಿಗೆ ತಿಳಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ನಿಮ್ಮ code ಪ್ರತಿಯೊಂದಕ್ಕೂ ಸರಿಯಾಗಿ ಸೇವೆ ನೀಡಬಹುದು. ಹೆಚ್ಚಿನ teams ಎರಡನ್ನೂ ಬಳಸುತ್ತವೆ.

API ಗಳಿಗೆ ಹಿಂದೆ ಸರಳವಾದ traffic model ಇತ್ತು. ಒಂದು developer ನೋಂದಾಯಿಸಿ, ಒಂದು key ಪಡೆದರು, ಒಂದು integration ಬರೆದು, ಆ integration ಸಮಯಪಟ್ಟಿ ಪ್ರಕಾರ ಅಥವಾ user ಏನಾದರೂ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ನಿಮ್ಮ endpoints ಅನ್ನು ಕರೆಸುತ್ತಿತ್ತು. API ಗಳಿಗಾಗಿ ಬಾಟ್ ನಿರ್ವಹಣೆ ಆ model ಸುತ್ತ ಬೆಳೆದು ಬಂದಿತು: key ಅನ್ನು authenticate ಮಾಡಿ, volume ಅನ್ನು ಮಿತಿಗೊಳಿಸಿ, ಸ್ಪಷ್ಟವಾಗಿ ದುರುಪಯೋಗದ traffic ಅನ್ನು ಶೋಧಿಸಿ, ಮತ್ತು ಸೇವೆಯನ್ನು ಉಳಿದ ಎಲ್ಲರಿಗೂ ಲಭ್ಯವಾಗುವಂತೆ ಇಡಿ.

ಆ model ಇನ್ನೂ ಮಾನ್ಯವಾಗಿದೆ, ಮತ್ತು ಅದಕ್ಕಾಗಿ ನಿರ್ಮಿಸಿದ tools ಗಳಿಗೆ ಇನ್ನೂ ಮಹತ್ವ ಇದೆ. ಬದಲಾದದ್ದು calls ಗಳ ಹಿಂದೆ ಯಾರು ಕುಳಿತಿದ್ದಾರೆ ಎಂಬುದು. ಅದೇ API key ಈಗ ನಿಮ್ಮ customer ನ app ಬಳಸುವ ವ್ಯಕ್ತಿಯಿಂದ, ಕೆಲಸ ಮಾಡಲು AI assistant ಅನ್ನು ಕೇಳಿದ ವ್ಯಕ್ತಿಯಿಂದ, ಮತ್ತು ರಾತ್ರಿ ತುಂಬಾ ಬಹುಹಂತದ task ನಡೆಸುವ autonomous agent ನಿಂದ ಬಂದ requests ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ನಿಮ್ಮ ಈಗಿನ controls ಒಂದು key ಮತ್ತು ಒಂದು request rate ಅನ್ನು ಮಾತ್ರ ನೋಡುತ್ತವೆ. ನಿಮ್ಮ product, support ಮತ್ತು policy ನಿರ್ಣಯಗಳಿಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ.

Proof of Actor ಆ gap ಅನ್ನು ತುಂಬುತ್ತದೆ. ಇದು ನಿಮ್ಮ API ಗೆ ಪ್ರತಿಯೊಂದು request ನಲ್ಲಿ ಯಾರು ಅಥವಾ ಏನು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ ಮತ್ತು evidence ಅನ್ನು ತಿಳಿಸುತ್ತದೆ, ನಂತರ ನಿರ್ಣಯವನ್ನು ನಿಮ್ಮ code ಗೆ ಬಿಡುತ್ತದೆ. ಈ page ಇದನ್ನು ಮುಖ್ಯ API bot protection layers ಗಳೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಪ್ರತಿಯೊಂದು ಎಲ್ಲಿ ಸೇರಿದೆ ಎಂಬುದು ನಿಮಗೆ ಕಾಣುತ್ತದೆ.

ಸಂಕ್ಷಿಪ್ತ ರೂಪ

	API ಬಾಟ್ ರಕ್ಷಣೆ	Proof of Actor
ಮುಖ್ಯ ಪ್ರಶ್ನೆ	ಈ request ಅನುಮತಿಸಲ್ಪಟ್ಟಿದೆಯೆ, authenticated ಆಗಿದೆಯೆ ಮತ್ತು limits ಒಳಗಿದೆಯೆ?	ಯಾರು ಅಥವಾ ಏನು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ, ಮತ್ತು 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	ಸಾಮಾನ್ಯವಾಗಿ key ಮಾನ್ಯವಾಗಿದ್ದರೆ ಅನುಮತಿಸಲಾಗುತ್ತದೆ, ಅಥವಾ ನಿಯಮದಿಂದ ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ	Unknown, ನೀವು ಪ್ರತಿ route ಗೆ ಆಯ್ಕೆಮಾಡುವ fallback ಜೊತೆಗೆ
ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಯಾರು ನಿರ್ಧರಿಸುತ್ತಾರೆ	Gateway ಮತ್ತು WAF ಸಂರಚನೆ	ನಿಮ್ಮ application code
install ಸಮಯದ default	Enforcement	Observation; ನೀವು policy ಸೇರಿಸುವ ತನಕ ಏನೂ ಬದಲಾಗುವುದಿಲ್ಲ
ಅತ್ಯುತ್ತಮವಾಗಿರುವುದು	Availability, abuse filtering, quotas, accountability	ಪ್ರತಿಯೊಂದು actor ಗೆ ಸರಿಯಾಗಿ ಸೇವೆ ನೀಡುವುದು ಮತ್ತು API ಬಳಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಕೆಳಗಿನ sections ಪ್ರತಿಯೊಂದು ಭಾಗವನ್ನು ವಿವರಿಸುತ್ತವೆ.

API ಬಾಟ್ ರಕ್ಷಣೆ ಏನು ಚೆನ್ನಾಗಿ ಮಾಡುತ್ತದೆ

ಪ್ರತಿ layer ಯಾವ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಹೇಳುವುದು ಉಪಯುಕ್ತ, ಏಕೆಂದರೆ Proof of Actor ಅವುಗಳೆಲ್ಲದ ಜೊತೆಯಲ್ಲೇ ಇರಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಯಾವುದನ್ನೂ ಬದಲಾಯಿಸಲು ಅಲ್ಲ.

API gateways

ಒಂದು gateway ನಿಮ್ಮ API ಗೆ ಮುಂಭಾಗದ ದ್ವಾರ. ಇದು connections ಗಳನ್ನು terminate ಮಾಡುತ್ತದೆ, API keys ಅಥವಾ tokens ಗಳನ್ನು authenticate ಮಾಡುತ್ತದೆ, requests ಗಳನ್ನು ಸರಿಯಾದ service ಗೆ route ಮಾಡುತ್ತದೆ, quotas ಗಳನ್ನು ಜಾರಿಗೆ ತರುತ್ತದೆ ಮತ್ತು ಬಹುಸಾರ billing ಮತ್ತು analytics ಗಾಗಿ ಬಳಕೆಯನ್ನು ದಾಖಲಿಸುತ್ತದೆ. ಇದು "ಈ caller ಗೆ ಪ್ರವೇಶವಿದೆಯೆ, ಮತ್ತು ಯಾವ ದ್ವಾರ ಮೂಲಕ?" ಎಂಬ ಪ್ರಶ್ನೆಗೆ ಪ್ರತಿಯೊಂದು endpoint ನಲ್ಲಿ ವೇಗವಾಗಿಯೂ ಸ್ಥಿರವಾಗಿಯೂ ಉತ್ತರಿಸುತ್ತದೆ.

WAF bot rules

Bot rules ಹೊಂದಿರುವ web application firewall ತಿಳಿದಿರುವ attack patterns ಮತ್ತು ದುರುಪಯೋಗದ automation ಗಾಗಿ traffic ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದು injection ಪ್ರಯತ್ನಗಳನ್ನು ಶೋಧಿಸಬಹುದು, ದುರುಪಯೋಗದ ಇತಿಹಾಸವಿರುವ sources ಗಳಿಂದ ಬಂದ traffic ಅನ್ನು block ಮಾಡಬಹುದು, ಮತ್ತು scraping ಅಥವಾ credential attacks ನಂತೆ ಕಾಣುವ requests ಗಳನ್ನು challenge ಅಥವಾ drop ಮಾಡಬಹುದು. ಇದು ನಿಮ್ಮ code ಗೆ ತಲುಪಬಾರಾದ traffic ವಿರುದ್ಧದ ನಿಮ್ಮ ಅತ್ಯುತ್ತಮ ರಕ್ಷಣೆಯಾಗಿದೆ.

API keys ಮತ್ತು tokens

Keys ಮತ್ತು tokens ನಿಮಗೆ accountability ನೀಡುತ್ತವೆ. ಪ್ರತಿಯೊಂದು request ಒಂದು account ಗೆ ಮ್ಯಾಪ್ ಆಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಯಾವ integration ಕರೆ ಮಾಡಿತು ಎಂಬುದು ನಿಮಗೆ ಗೊತ್ತಾಗುತ್ತದೆ, access ಅನ್ನು revoke ಮಾಡಬಹುದು, ಮತ್ತು ಬಳಕೆಗೆ ಸಂಬಂಧಿಸಿದ ಹೊಣೆಗಾರಿಕೆಯನ್ನು ನಿಗದಿಪಡಿಸಬಹುದು. Scoped tokens ಇನ್ನೂ ಮುಂದೆ ಹೋಗಿ caller ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತವೆ.

Rate limits

Rate limits availability ಅನ್ನು ರಕ್ಷಿಸುತ್ತವೆ. ಒಂದೇ integration ಎಲ್ಲರಿಗೂ ಮೀಸಲಾದ capacity ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದನ್ನು ಅವು ತಡೆಯುತ್ತವೆ, ಮತ್ತು brute-force ಹಾಗೂ enumeration ಪ್ರಯತ್ನಗಳನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತವೆ. Per-key ಮತ್ತು per-route limits ಗಳು ಮಾನಕ, ಪರಿಣಾಮಕಾರಿ control ಆಗಿವೆ.

ಒಟ್ಟಾಗಿ ಈ layers ಗಳು protection ಮತ್ತು accountability ಸಂಬಂಧಿತ ಪ್ರಶ್ನೆಗಳಿಗೆ ಬಹಳ ಚೆನ್ನಾಗಿ ಉತ್ತರಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ಇಟ್ಟುಕೊಳ್ಳಿ.

ಅವು ಉತ್ತರಿಸಲು ನಿರ್ಮಿಸಲಾದ ಪ್ರಶ್ನೆ ಅಲ್ಲ

ಆ layers ಗಳೆಲ್ಲವೂ authenticated request ಹಿಂದಿರುವ ಯಾವ kind of actor ಎಂದು ಹೇಳಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಿಲ್ಲ. ಮಾನ್ಯ key ಯಾವ account integration ಅನ್ನು ಹೊಂದಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ. ಅದು ಇದನ್ನು ಹೇಳುವುದಿಲ್ಲ:

ಈ ನಿರ್ದಿಷ್ಟ call ನಿಮ್ಮ customer ನ app ನಲ್ಲಿ button ಒತ್ತುವ ವ್ಯಕ್ತಿಯಿಂದ ಬಂದಿತೇ,
ವ್ಯಕ್ತಿಯೊಬ್ಬರು AI assistant ಅನ್ನು action ಮಾಡಲು ಕೇಳಿದರೇ,
autonomous agent ದೀರ್ಘ task ನ ಒಂದು ಹೆಜ್ಜೆಯಾಗಿ call ಮಾಡಿತೇ,
ಅಥವಾ ಯಾರಿಗೂ ಖಚಿತವಾಗಿ ತಿಳಿಯುವುದಿಲ್ಲವೋ.

ಆ ವ್ಯತ್ಯಾಸ ಪ್ರತಿಮಾಸಕ್ಕೂ ಹೆಚ್ಚು ಮುಖ್ಯವಾಗುತ್ತಿದೆ. CRM integration, scheduling tool ಅಥವಾ developer platform ಅನ್ನು ಸೇವಿಸುವ API ಈಗ ಹೆಚ್ಚಾಗಿ human-driven apps ಗಳಿಗೆ ಸೇವೆ ಮಾಡುವ ಅದೇ keys ಗಳ ಮೂಲಕ agent traffic ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ನೀವು agents ಗೆ structured response ನೀಡಲು, agents ನಡೆಸುವ high-impact writes ಗಳಿಗೆ confirmation ಕಡ್ಡಾಯಗೊಳಿಸಲು, AI-assisted submissions ಗಳನ್ನು label ಮಾಡಲು, ಅಥವಾ ನಿಮ್ಮ API ಬಳಕೆಯ ಎಷ್ಟು ಭಾಗ agent-driven ಎಂಬುದನ್ನು ಅಳೆಯಲು ಬಯಸಿದರೆ, actor context ಬೇಕಾಗುತ್ತದೆ.

Proof of Actor ಒಂದು API ಗೆ ಏನು ಸೇರಿಸುತ್ತದೆ

Proof of Actor ಪ್ರತಿ interaction ಗೆ ನಾಲ್ಕು classes ಗಳಲ್ಲಿ ಒಂದನ್ನು ನೀಡುತ್ತದೆ:

Human: ಗಮನಿಸಬಹುದಾದ signals ಗಳು human-directed interaction ಅನ್ನು ಸೂಚಿಸುತ್ತವೆ.
Human + AI: ವ್ಯಕ್ತಿಯೊಬ್ಬರು AI ನೆರವಿನಿಂದ interaction ಅನ್ನು ನಿರ್ದೇಶಿಸಿದ್ದಾರೆ, ಮತ್ತು ಅದು supported integration ಮೂಲಕ ಘೋಷಿಸಲ್ಪಟ್ಟಿರಬಹುದು ಅಥವಾ ಗಮನಿಸಲ್ಪಟ್ಟಿರಬಹುದು.
Agent: automated ಅಥವಾ agent-origin interaction.
Unknown: evidence ವಿಶ್ವಾಸಾರ್ಹ ನಿರ್ಧಾರವನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

ಪ್ರತಿಯೊಂದು result ತನ್ನ evidence basis ನ್ನೂ ತಿಳಿಸುತ್ತದೆ:

Verified: ಉದಾಹರಣೆಗೆ ಪ್ರಕಟಿತ key ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಲಾದ HTTP Message Signature (RFC 9421).
Declared: client ಅಥವಾ ನಿಮ್ಮ own application ಅದನ್ನು ಹೇಳಿದೆ.
Inferred: behavioral ಅಥವಾ contextual signals, ಸ್ಪಷ್ಟವಾಗಿ inference ಎಂದು ಲೇಬಲ್ ಮಾಡಲಾಗಿದೆ.
Unknown: ವಿಶ್ವಾಸಾರ್ಹ basis ಇಲ್ಲ.

API ಗಳಿಗಾಗಿ, verified basis ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತ. ತಮ್ಮ requests ಗಳಿಗೆ sign ಮಾಡುವ agents ಗಳನ್ನು ಅವರ ಪ್ರಕಟಿತ keys ಗಳ ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಬಹುದು, ಇದು IETF Web Bot Auth ಕೆಲಸದ ಹಿಂದೆ ಇರುವ approach ಆಗಿದೆ. ಹಿನ್ನೆಲೆಯಿಗಾಗಿ product teams ಗಾಗಿ Web Bot Auth ವಿವರಣೆ ನೋಡಿ, ಮತ್ತು implementation ಭಾಗಕ್ಕಾಗಿ signed agent requests ಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮಾರ್ಗದರ್ಶಿಯನ್ನು ನೋಡಿ.

ಇಲ್ಲಿ ಒಂದು ಮಿತಿ ಮುಖ್ಯ. ಮಾನ್ಯ 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 ಗಾಗಿ ಅದು ಕಡಿಮೆ ಉಪಯುಕ್ತ, ಏಕೆಂದರೆ ಅದು ಮಾನ್ಯ request ಮಾನವ ಚಾಲಿತವಾಗಿತೇ ಅಥವಾ agent ಚಾಲಿತವಾಗಿತೇ ಎಂದು ಹೇಳುವುದಿಲ್ಲ, ಮತ್ತು ಅದು verified facts ಗಳನ್ನು inference ನಿಂದ ಬೇರ್ಪಡಿಸುವುದಿಲ್ಲ.

API keys ಗಳು ವಿರುದ್ಧ ದಿಕ್ಕಿನ ಮಿತಿಯನ್ನು ಹೊಂದಿವೆ. ಅವು ownership ಬಗ್ಗೆ ನಿಖರವಾಗಿವೆ ಮತ್ತು actor ಬಗ್ಗೆ ಮೌನವಾಗಿವೆ. ಒಂದು customer ನ key ಒಂದೇ ಗಂಟೆಯಲ್ಲಿ ಎಲ್ಲಾ ನಾಲ್ಕು classes ಗಳನ್ನು ಹೊತ್ತುಕೊಳ್ಳಬಹುದು.

Proof of Actor ಈ ಎರಡೂ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಾಣುವಂತೆಯೇ ಇಡುತ್ತದೆ. ನಿಮ್ಮ API key ನಿಂದ account ಅನ್ನು, Proof of Actor ನಿಂದ actor class ಅನ್ನು, ಮತ್ತು ಅದನ್ನು ಬೆಂಬಲಿಸುವ basis ಅನ್ನು ನೋಡುತ್ತದೆ. ಪ್ರತಿಯೊಂದು layer ತನ್ನಲ್ಲೇ ಚೆನ್ನಾಗಿರುವ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸುತ್ತದೆ.

ಪ್ರತಿ one ಎಲ್ಲಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

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 ಮೂಲಕ ಸೇರಿಸಬಹುದು. ಸಂಪೂರ್ಣ ಪಟ್ಟಿಗಾಗಿ integrations ನೋಡಿ. ಇದು ನಿಮ್ಮ application ಒಳಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದರಿಂದ, ನಿಮ್ಮ API ಗೆ ತಿಳಿದಿರುವ ವಿಷಯಗಳನ್ನು ಬಳಸಬಹುದು: route, workflow, client ತನ್ನನ್ನು ತಾನೇ declared ಮಾಡಿಕೊಂಡಿದೆಯೇ, ಮತ್ತು signature verified ಆಗಿದೆಯೇ.

Routing ನಿರ್ಣಯಗಳು ನಿಮ್ಮ code ನಲ್ಲೇ ಇರುತ್ತವೆ

Proof of Actor default ಆಗಿ ಏನನ್ನೂ block ಮಾಡುವುದಿಲ್ಲ. ಇದು observation mode ನಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದನ್ನು install ಮಾಡಿದರೆ ನಿಮ್ಮ API ಹೇಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಏನೂ ಬದಲಾವಣೆ ಆಗುವುದಿಲ್ಲ. ನೀವು endpoint ಪ್ರಕಾರ ನಿಮ್ಮ actor mix ಅನ್ನು ನೋಡಬಹುದು, individual results ಗಳ evidence ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು, ಮತ್ತು ನಿಮ್ಮ Unknown rate ಅನ್ನು ಗಮನಿಸಬಹುದು.

ನೀವು ಸಿದ್ಧರಾದಾಗ, route ಪ್ರತಿ, actor class ಪ್ರತಿ ಮತ್ತು basis ಪ್ರತಿ application-defined policies ಗಳನ್ನು ಬರೆಯುತ್ತೀರಿ. ಸಾಮಾನ್ಯ outcomes ಗಳು:

Allow: request ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸೇವಿಸು.
Adapt: verified agent ಗಾಗಿ structured ಅಥವಾ ಕಡಿತಗೊಂಡ response ಅನ್ನು ಹಿಂತಿರುಗಿಸು.
Challenge: ಹೆಚ್ಚುವರಿ confirmation ಹಂತವನ್ನು ಕೇಳು, ಉದಾಹರಣೆಗೆ high-impact write ಗೆ human approval.
Review: ಕ್ರಿಯೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಒಬ್ಬ ವ್ಯಕ್ತಿಗೆ queue ಮಾಡು.
Rate-limit: ನಿರ್ದಿಷ್ಟ route ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ class ಮತ್ತು basis ಗೆ ಇನ್ನಷ್ಟು ಕಠಿಣ limit ಅನ್ನು ಅನ್ವಯಿಸು.

Policy ಅನ್ನು enforced ಮಾಡುವ ಮೊದಲು ನೈಜ traffic ವಿರುದ್ಧ preview ಮಾಡಬಹುದು, ನಂತರ route by route ಜಾರಿಗೆ ತರಬಹುದು. actor-aware policies ಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ rollout ಮಾಡುವುದರ ಮಾರ್ಗದರ್ಶಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಒಳಗೊಂಡಿದೆ, ಮತ್ತು agents ಗಳನ್ನು block ಮಾಡದೆ sensitive actions ಗಳನ್ನು ರಕ್ಷಿಸುವುದು ಸಾಮಾನ್ಯ patterns ಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

Unknown API callers ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಪ್ರತಿ API ಕೂಡ ವಿಶ್ವಾಸದಿಂದ ವರ್ಗೀಕರಿಸಲಾಗದ traffic ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಸಾಂಪ್ರದಾಯಿಕ controls ಗಳಲ್ಲಿ, ಮಾನ್ಯ key ಇದ್ದರೆ request ಸಾಮಾನ್ಯವಾಗಿ ಮುಂದಕ್ಕೆ ಹೋಗುತ್ತದೆ, ಮತ್ತು ಅಮಾನ್ಯವಾದರೆ ಹೋಗುವುದಿಲ್ಲ. ಮಧ್ಯದಲ್ಲಿ ಏನೂ ಇಲ್ಲ.

Proof of Actor ನಿಮಗೆ ಸ್ಪಷ್ಟವಾದ Unknown result ಅನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ route ಗೆ fallback ಆಯ್ಕೆಮಾಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ. Read-only catalog endpoints ಗಳನ್ನು ತೆರೆದೆಯೇ ಇಡಬಹುದು. Account ಬದಲಾವಣೆಗಳಿಗೆ ನಿಮ್ಮ ಈಗಿನ ಇನ್ನಷ್ಟು ಕಟ್ಟುನಿಟ್ಟಾದ checks ಗಳನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಬಹುದು. Bulk exports ಗಳನ್ನು review ಗೆ ಕಳುಹಿಸಬಹುದು. ವಿವರಗಳಿಗಾಗಿ Unknown traffic ನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು unknown automated traffic ನೋಡಿ.

ಅವು ಹೇಗೆ ಜೊತೆಯಾಗುತ್ತವೆ

ಅತ್ಯಂತ ಬಲವಾದ API setup ಪ್ರತಿಯೊಂದು layer ಅನ್ನು ತನ್ನದೇ ಕೆಲಸಕ್ಕೆ ಬಳಸುತ್ತದೆ:

Edge ನಲ್ಲಿ, WAF ದುರುಪಯೋಗದ ಮತ್ತು malformed traffic ಅನ್ನು ಶೋಧಿಸುತ್ತದೆ.
Gateway ನಲ್ಲಿ, keys ಗಳನ್ನು authenticate ಮಾಡಲಾಗುತ್ತದೆ, quotas ಜಾರಿಗೆ ತರಲಾಗುತ್ತದೆ ಮತ್ತು ಬಳಕೆಯನ್ನು ದಾಖಲಿಸಲಾಗುತ್ತದೆ.
API ಒಳಗೆ, Proof of Actor ಮೂಲಕ ಹೋಗುವ ಪ್ರತಿಯೊಂದು request ಅನ್ನು ವರ್ಗೀಕರಿಸಿ ಅದರ basis ಅನ್ನು ತಿಳಿಸುತ್ತದೆ.
ನಿಮ್ಮ handlers ಗಳಲ್ಲಿ, policies class ಮತ್ತು basis ಅನ್ನು ಬಳಸಿಕೊಂಡು response ಆಯ್ಕೆಮಾಡುತ್ತವೆ: human-driven call ಗೆ ಸಾಮಾನ್ಯ handling, verified agent ಗೆ structured response, agent-driven high-impact write ಗೆ confirmation step, Unknown ಗೆ fallback.
Analytics ನಲ್ಲಿ, ನಿಮ್ಮ ತಂಡವು ಯಾವ endpoints ಮತ್ತು workflows ಗಳನ್ನು ಪ್ರತಿ actor class ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು gateway ನಿಂದ ಬಂದ account data ಜೊತೆಗೆ ನೋಡುತ್ತದೆ.

ಈ stack ನಲ್ಲಿ ಏನೂ duplicate ಆಗುವುದಿಲ್ಲ. Gateway account ಅನ್ನು ತಿಳಿದಿದೆ, WAF threat patterns ಗಳನ್ನು ತಿಳಿದಿದೆ, ಮತ್ತು Proof of Actor actor ಅನ್ನು ತಿಳಿದಿದೆ.

ಯಾವುದರ ಮೇಲೆ ಯಾವಾಗ ಗಮನ ಹರಿಸಬೇಕು

ನಿಮ್ಮ ಮುಖ್ಯ ಸಮಸ್ಯೆಗಳು abuse, availability ಅಥವಾ unmetered usage ಆಗಿದ್ದರೆ ಮೊದಲು API ಬಾಟ್ ರಕ್ಷಣೆ ಮೇಲೆ ಗಮನ ಹರಿಸಿ: auth endpoints ಗಳ ಮೇಲಿನ credential attacks, aggressive scraping, ಅಥವಾ ಒಂದು integration ಇತರರಿಗೆ capacity ಕಡಿಮೆ ಮಾಡುವುದು.

ನಿಮ್ಮ ಮುಖ್ಯ ಪ್ರಶ್ನೆಗಳು ನಿಮ್ಮ callers ಗಳ ಬಗ್ಗೆ ಆಗಿದ್ದರೆ Proof of Actor ಮೇಲೆ ಗಮನ ಹರಿಸಿ: ನಿಮ್ಮ API traffic ನ ಎಷ್ಟು ಭಾಗ agent-driven ಆಗಿದೆ, ಯಾವ agents ಯಾವ endpoints ಗಳನ್ನು ಕರೆಸುತ್ತವೆ, human-driven ಮತ್ತು agent-driven ಬಳಕೆ ಎಲ್ಲಿ ಭಿನ್ನವಾಗುತ್ತದೆ, ಮತ್ತು ಯಾವ routes ಗಳಿಗೆ actor-aware policy ಬೇಕು. APIs use case ಮತ್ತು AI agent identification for APIs ಇನ್ನಷ್ಟು ವಿವರಿಸುತ್ತವೆ.

ಉತ್ಪಾದನಾ API ನಡೆಸುತ್ತಿರುವ ಹೆಚ್ಚಿನ teams ಗಳಿಗೆ ಎರಡಕ್ಕೂ ಉತ್ತರಗಳು ಬೇಕಾಗುತ್ತವೆ.

ಆರಂಭಿಸಿ

Proof of Actor private beta ಯಲ್ಲಿದೆ. ಆಯ್ಕೆಯಾದ founding developer teams ಗಳು ಒಪ್ಪಿಕೊಂಡ usage limits ಗಳ ಒಳಗೆ up to 12 months free access ಪಡೆಯಬಹುದು, ಯಾವುದೇ automatic billing ಇಲ್ಲದೆ. early access ಗಾಗಿ ಅರ್ಜಿ ಸಲ್ಲಿಸಿ ಮತ್ತು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುವ API ಮತ್ತು callers ಗಳ ಬಗ್ಗೆ ನಮಗೆ ತಿಳಿಸಿ.

DEVELOPERS ಗಾಗಿ

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: ಫಲಿತಾಂಶದ ಹಿಂದೆ ಇರುವ signals, ಇದರಿಂದ ನಿಮ್ಮ ತಂಡಕ್ಕೆ ಕಾರಣ ಕಾಣುತ್ತದೆ.

observation mode ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿ: ನಿಮ್ಮ logs ಗಳ ಪಕ್ಕದಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ದಾಖಲಿಸಿ ಮತ್ತು ನೀವು ಒಂದು policy ಆಯ್ಕೆ ಮಾಡುವವರೆಗೆ ಏನನ್ನೂ ಬದಲಾಯಿಸಬೇಡಿ. Node.js ಏಕೀಕರಣ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಓದಿ

ಪದೇಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

Proof of Actor ನನ್ನ API gateway ಅಥವಾ WAF ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆಯೆ?

ಇಲ್ಲ. ನಿಮ್ಮ gateway ಇನ್ನೂ keys ಗಳನ್ನು authenticate ಮಾಡುತ್ತದೆ ಮತ್ತು quotas ಗಳನ್ನು ಜಾರಿಗೆ ತರುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ WAF ಇನ್ನೂ ದುರುಪಯೋಗದ traffic ಅನ್ನು ಶೋಧಿಸುತ್ತದೆ. Proof of Actor ನಿಮ್ಮ API ಒಳಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಮೂಲಕಾದ requests ಗಳಿಗೆ actor context ಅನ್ನು ಸೇರಿಸುತ್ತದೆ. ನಿಮ್ಮ ಈಗಿನ controls ಗಳನ್ನು ಹಾಗೆಯೇ ಇಡಿ.

ಪ್ರತಿ caller ಗೆ API key ಇದ್ದರೆ, ನನಗೆ actor context ಏಕೆ ಬೇಕು?

ಒಂದು API key ಒಂದು integration ಗೆ ಮಾಲೀಕನಾದ account ಅನ್ನು ಗುರುತಿಸುತ್ತದೆ. ಆದರೆ ನಿರ್ದಿಷ್ಟ request ನಿಮ್ಮ customer ನ app ನಲ್ಲಿ button ಕ್ಲಿಕ್ ಮಾಡುವ ವ್ಯಕ್ತಿಯಿಂದ ಬಂದಿತೇ, AI assistant ಬಳಸುವ ವ್ಯಕ್ತಿಯಿಂದ ಬಂದಿತೇ, ಅಥವಾ task ನಡೆಸುವ autonomous agent ನಿಂದ ಬಂದಿತೇ ಎಂಬುದನ್ನು ಅದು ಹೇಳುವುದಿಲ್ಲ. Proof of Actor ಅದನ್ನು ಅದರ basis ನೊಂದಿಗೆ ವರದಿ ಮಾಡುತ್ತದೆ.

ಯಾವ agent ನನ್ನ API ಅನ್ನು ಕರೆುತ್ತಿದೆ ಎಂದು Proof of Actor ಪರಿಶೀಲಿಸಬಹುದೇ?

ಒಂದು client ತನ್ನ requests ಗಳನ್ನು HTTP Message Signatures (RFC 9421) ನೊಂದಿಗೆ sign ಮಾಡಿ ತನ್ನ key ಅನ್ನು ಪ್ರಕಟಿಸಿದಾಗ, Proof of Actor signature ಅನ್ನು ಪರಿಶೀಲಿಸಿ verified basis ಅನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. ಮಾನ್ಯ signature ಯಾವ key request ಅನ್ನು sign ಮಾಡಿತು ಎಂಬುದನ್ನು ಸಾಬೀತುಪಡಿಸುತ್ತದೆ. ಆದರೆ agent ಆ ಕ್ರಿಯೆ ಮಾಡಲು authorized ಆಗಿದೆಯೆಂಬುದನ್ನು ಅದು ಸಾಬೀತುಪಡಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ authorization ನಿಮ್ಮ code ನಲ್ಲಿಯೇ ಇರುತ್ತದೆ.

Proof of Actor ನನ್ನ API traffic ಮೇಲೆ rate-limiting ಅಥವಾ blocking ಆರಂಭಿಸುವುದೇ?

ಇಲ್ಲ. ಇದು observation mode ನಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ ಮತ್ತು default ಆಗಿ ಏನನ್ನೂ block ಮಾಡುವುದಿಲ್ಲ. Rate-limit ನೀವು policy ಯಲ್ಲಿ route, actor class ಮತ್ತು basis ಪ್ರಕಾರ ಆಯ್ಕೆಮಾಡಬಹುದಾದ outcomes ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಮತ್ತು enforcement ನಿಮ್ಮ own code ನಲ್ಲಿ ಇರುತ್ತದೆ.

ಒಂದು API ಗೆ Proof of Actor ಅನ್ನು ಹೇಗೆ ಸೇರಿಸಲಿ?

Founding teams ಗಳು Node.js middleware, Next.js, ಒಂದು edge integration ಅಥವಾ generic HTTP API ಬಳಸಬಹುದು. MCP servers ಗಳಿಗೆ ತಮ್ಮದೇ integration ಇದೆ. ವಿವರಗಳಿಗಾಗಿ integrations page ನೋಡಿ.

ನಾವು classify ಮಾಡಲು ಸಾಧ್ಯವಾಗದ callers ಗಳಿಗೆ ಏನಾಗುತ್ತದೆ?

ಅವುಗಳನ್ನು Unknown ಎಂದು ವರದಿ ಮಾಡಲಾಗುತ್ತದೆ, ಇದು first-class result. ನೀವು ಪ್ರತಿ route ಗೆ fallback ಅನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತೀರಿ, ಉದಾಹರಣೆಗೆ read-only endpoints ಗಳಲ್ಲಿ allow ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಹೆಚ್ಚು ಕಟ್ಟುನಿಟ್ಟಾದ checks ಗಳನ್ನು write endpoints ಗಳಲ್ಲಿ ಇಟ್ಟುಕೊಳ್ಳಿ.

ನಿಮ್ಮ app ಅನ್ನು ಯಾರು ಬಳಸುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತಿಳಿಯಿರಿ.

founding developers ನ ಸಣ್ಣ ಗುಂಪಿಗಾಗಿ private beta.

ಮುಂಗಡ ಪ್ರವೇಶ ಪಡೆಯಿರಿ ಮೌಲ್ಯವನ್ನು ವೀಕ್ಷಿಸಿ

ಮೊದಲು ಮಾತನಾಡಲು ಇಷ್ಟವಿದೆಯೆ? ಸ್ಥಾಪಕರೊಂದಿಗೆ ಮಾತನಾಡಿ