Somebody at Sentry filed a bug last month: Cursor Automations started hitting rate-limit errors almost immediately after authenticating. The bucket was sized for humans — 60 requests per 60 seconds — and an agent tore through it in seconds.
That's the MCP auth problem in miniature. You've got a server exposing tools. Agents call those tools. You want to slow down abuse, charge per call, or just make sure you don't blow up your LLM budget on some runaway loop. How do you do that without wiring up a full OAuth stack that breaks the first time an agent doesn't have a browser to open?
Three real options exist right now. Here's how they compare.
Option 1: OAuth 2.1 (the spec says so)
The MCP spec mandates OAuth 2.1 for authorization. If you're building a production server for enterprise customers — actual humans with accounts — this is the right call. You get scoped access, token revocation, audit trails. SSO works. Compliance teams stop emailing you.
The problem is agents. OAuth 2.1 has an authorization code flow that requires a redirect URI. An agent running headless doesn't have a browser. DPoP and Workload Identity Federation are on the MCP roadmap but not shipped yet. If you need auth today and your callers are mostly agents, OAuth puts you in a hole.
Good fit: enterprise SaaS, human-driven clients, compliance-heavy contexts.
Bad fit: anonymous agents, public APIs, pay-per-call services.
Option 2: L402 Lightning payments
L402 is an HTTP extension where a server responds to an unauthorized request with 402 Payment Required and an invoice in the WWW-Authenticate header. The client pays it over Lightning and retries with the preimage as a credential.
Two npm packages ship L402 for MCP right now: lightning-wallet-mcp and l402-kit-mcp. The model is clean: each tool call costs a fixed number of sats. No accounts, no sessions, no user. An agent with a Lightning wallet (Alby, Phoenixd, NWC) can handle the whole flow programmatically.
# First call — server responds with 402
curl -X POST https://your-mcp-server/tools/call \
-H "Content-Type: application/json" \
-d '{"name": "expensive_tool", "arguments": {}}'
# HTTP/1.1 402 Payment Required
# WWW-Authenticate: L402 invoice="lnbc...", macaroon="..."
# Pay the invoice over Lightning, get the preimage
# Retry with credentials
curl -X POST https://your-mcp-server/tools/call \
-H "Authorization: L402 <macaroon>:<preimage>" \
-H "Content-Type: application/json" \
-d '{"name": "expensive_tool", "arguments": {}}'
# HTTP/1.1 200 OK
Good fit: agents with Lightning wallets, micropayment-per-call APIs, Bitcoin-native monetization.
Bad fit: agents without wallets, free tiers, contexts where payment friction kills adoption.
Option 3: Proof-of-work
PoW is the weird one. Instead of paying money, the caller burns CPU to solve a hashcash-style puzzle. The server sets a difficulty. The caller grinds until they find a nonce. No wallet required.
# Get a challenge
curl https://your-mcp-server/api/challenge
# {"challenge": "abc123", "difficulty": 4, "algorithm": "sha256"}
# Solve it
npx @powforge/captcha solve --challenge abc123 --difficulty 4
# {"nonce": "7f3a...", "solution": "0000..."}
# Submit with solution in header
curl -X POST https://your-mcp-server/tools/call \
-H "X-PoW-Solution: challenge=abc123,nonce=7f3a..." \
-H "Content-Type: application/json" \
-d '{"name": "tool", "arguments": {}}'
The cost scales with difficulty. A legitimate caller solving once is fine. An abuser trying to hammer 10,000 calls hits a wall because each requires fresh compute. No central authority. No wallet. No redirect.
@powforge/captcha-mcp ships this as middleware for existing MCP servers. Wrap your server, set a difficulty, and callers solve before tool calls go through. It also supports L402 as an escape valve: pay sats instead of grinding if you'd rather not burn CPU.
Good fit: anonymous agents, public APIs, abuse prevention without monetization, PoW-or-pay dual rail.
Bad fit: high-throughput legitimate callers (CPU cost adds latency), real-time tools where every millisecond counts.
The comparison
| OAuth 2.1 | L402 Lightning | Proof-of-Work | |
|---|---|---|---|
| Requires user account | Yes | No | No |
| Requires Lightning wallet | No | Yes | No |
| Works headless today | Partial | Yes | Yes |
| Revenue per call | No | Yes (sats) | No |
| Stateless | No | Yes | Yes |
An Astrix Security study this year found 88% of MCP servers require credentials of some kind but document almost none of it. The OpenClaw scan found 42,000+ unauthenticated MCP instances publicly exposed in January 2026. Most of those aren't enterprise installs — they're side projects and weekend builds.
For that crowd, OAuth is overkill. L402 is elegant if the caller has a wallet. PoW gives you friction without a wallet requirement — callers can always get through, they just can't do it for free at scale.
The decision tree
- Building for enterprise with human users? OAuth 2.1. The spec points here and compliance teams need it.
- Monetizing per tool call, callers have Lightning wallets? L402. Clean, stateless, Bitcoin-native.
- Public API, anonymous agents, no accounts? PoW — or PoW with L402 escape valve.
- Unsure? Start with PoW for the free tier and L402 for a paid tier. Add OAuth when an enterprise customer asks for it.
The Sentry rate-limit bug is fixable with any of these. But if you're building for agents first, OAuth is the last thing you reach for — not the first.
-
@powforge/captcha-mcp(PoW + L402 middleware): https://www.npmjs.com/package/@powforge/captcha-mcp -
@powforge/captcha(standalone solver): https://www.npmjs.com/package/@powforge/captcha - Sentry MCP issue #844: https://github.com/getsentry/sentry-mcp/issues/844
Top comments (1)
Great breakdown of an under-discussed problem - most MCP servers ship with zero auth because the tutorials skip it, which is fine on localhost and a disaster the moment it's reachable. The three you picked map cleanly to different threat/business models: OAuth for "known users / standard SaaS auth," L402 (Lightning 402) for "pay-per-call machine-native metering," and proof-of-work for "no accounts but stop abuse/DoS." The interesting one is L402 - micropayment-gated tool calls is exactly the primitive an agent economy needs (agents paying agents per call without human-issued API keys).
The pragmatic take: most builders want OAuth now (it's what their stack already speaks), but L402 is the one to watch because it solves the "agent needs to pay for a tool autonomously" problem that's coming fast. It's the kind of boring-but-load-bearing layer I bake in as a default with Moonshift (prompt to a shipped SaaS) rather than leaving as a TODO. Genuinely useful post - which did you land on for your own servers, and is L402 actually usable today or still early/experimental?