DEV Community: Zach Miller

x402 Beyond EVM: How to Gate Any API Behind Crypto Micropayments on Cosmos

Zach Miller — Mon, 16 Mar 2026 23:12:19 +0000

A step-by-step guide to implementing the x402 HTTP 402 Payment Required pattern on a Cosmos SDK chain using ClawPurse Gateway and NTMPI tokens — no EVM, no facilitator, no custody.

Everyone's talking about x402 — the open payment protocol that brings HTTP 402 Payment Required back from the dead. Coinbase launched it, Cloudflare joined the foundation, Vercel shipped middleware for it, and Circle demoed AI agents autonomously paying for API calls.

But here's the thing: every x402 implementation so far runs on EVM chains (Base, Polygon, Solana) and settles in stablecoins through a centralized facilitator.

What if you're building on Cosmos? What if you're a DePIN node operator who already earns and stakes a native token? What if you want to self-host the whole stack with no facilitator dependency?

That's what ClawPurse does. It implements the same x402 pattern — 402 invoice → on-chain payment → retry with proof — on the Neutaro blockchain (Cosmos SDK) with NTMPI tokens. No facilitator. No custody. Fully self-hosted.

Here's how to set it up in under 5 minutes.

What we're building

A gated API where:

Any request to a protected endpoint returns 402 Payment Required with an invoice
The caller (human, script, or AI agent) pays on-chain with NTMPI
The caller retries with an X-Payment-Proof header
The gateway verifies the payment on Neutaro and proxies to your upstream API

This is the exact x402 flow. The only difference from Coinbase's version: we verify directly against the Neutaro REST API instead of routing through a facilitator.

Prerequisites

Node.js 18+
A Neutaro wallet address (we'll create one)
Docker (optional, for gateway deployment)

Step 1: Install the ClawPurse agentic wallet

ClawPurse is a local-only CLI wallet with encrypted keystores and guardrails built for autonomous agents.

git clone https://github.com/mhue-ai/ClawPurse.git
cd ClawPurse
npm install && npm run build && npm link

# Create a wallet
clawpurse init --password yourpassword

# Get your address
clawpurse address
# → neutaro1abc...xyz

# Check balance
clawpurse balance --password yourpassword

Need tokens? Grab free NTMPI from the Timpi Drip faucet — it uses proof-of-work instead of CAPTCHA, so it works for AI agents too.

Step 2: Deploy the 402 gateway

git clone https://github.com/mhue-ai/clawpurse-gateway.git
cd clawpurse-gateway
npm install

cp .env.example .env

Edit .env:

PORT=4020
GATEWAY_UPSTREAM=http://localhost:3000
GATEWAY_PAYMENT_ADDRESS=neutaro1abc...xyz  # your address from step 1
GATEWAY_DEFAULT_PRICE=0.001                # price per request in NTMPI
JWT_SECRET=your-random-secret

Start a test upstream (the gateway includes one):

npm run test:upstream

Start the gateway:

npm run dev

That's it. Your API is now gated behind NTMPI micropayments.

Step 3: Test the x402 flow

# Hit the gated endpoint
curl http://localhost:4020/api/test

You get back:

{
  "error": "Payment required",
  "payment": {
    "invoiceId": "inv_abc123",
    "amount": "0.001",
    "address": "neutaro1abc...xyz",
    "memo": "inv_abc123"
  }
}

Pay with ClawPurse:

clawpurse send neutaro1abc...xyz 0.001 \
  --memo inv_abc123 \
  --password yourpassword \
  --yes

Retry with proof:

curl -H "X-Payment-Proof: inv_abc123" \
  http://localhost:4020/api/test

→ 200 OK with your upstream data. Done.

How this compares to Coinbase x402

	Coinbase x402	ClawPurse Gateway
Chain	Base, Polygon, Solana	Neutaro (Cosmos SDK)
Token	USDC, ERC-20s	NTMPI
Verification	Centralized facilitator	Direct on-chain query
Header	`X-PAYMENT`	`X-Payment-Proof`
Wallet	Coinbase Agentic Wallets	ClawPurse CLI + API
Deploy	SDK/middleware	Docker or bare metal
Custody	Facilitator-mediated	Zero custody, self-hosted

The key architectural difference: Coinbase x402 uses a facilitator — a server that verifies and settles payments on behalf of the resource server. ClawPurse skips this entirely. The gateway queries the Neutaro REST API directly (/cosmos/tx/v1beta1/txs) to verify the payment amount, memo, and block confirmations.

This means:

No trust dependency on a third-party facilitator
No rate limits from facilitator API calls
No registration — deploy and go

Making it agent-friendly

The whole point of x402 is that machines can pay for things. Here's a Python agent that handles the 402 flow autonomously:

import requests, subprocess

def paid_fetch(url):
    res = requests.get(url)

    if res.status_code == 402:
        inv = res.json()["payment"]

        # Pay with ClawPurse
        subprocess.run([
            "clawpurse", "send",
            inv["address"], inv["amount"],
            "--memo", inv["memo"], "--yes"
        ])

        # Retry with proof
        res = requests.get(url, headers={
            "X-Payment-Proof": inv["invoiceId"]
        })

    return res.json()

data = paid_fetch("http://gateway:4020/api/data")

ClawPurse also includes guardrails specifically designed for agent autonomy:

Spending limits — cap how much an agent can send per transaction or per day
Destination allowlists — restrict which addresses an agent can pay
Confirmation thresholds — require N block confirmations before considering payment settled

Configure these with the guardrail wizard:

clawpurse guardrails --password yourpassword

Prepaid balances for high-frequency agents

For agents making hundreds of API calls, paying on-chain every time is wasteful. ClawPurse Gateway supports prepaid balances — deposit once, then make many calls:

# Enable in .env
GATEWAY_PREPAID=true

The agent deposits NTMPI once:

curl -X POST http://localhost:4020/prepaid/deposit \
  -H "Content-Type: application/json" \
  -d '{"txHash": "ABC123...", "clientId": "agent-001"}'

Then subsequent requests just include the client ID:

curl -H "X-Client-Id: agent-001" \
  http://localhost:4020/api/data

The gateway deducts from the balance per call. No repeated on-chain transactions.

Route-level pricing

Not all endpoints are equal. Charge more for writes, less for reads:

GATEWAY_ROUTES={"POST /api/generate":0.01,"GET /api/status":0.0001}

Default price applies to everything else.

Why this matters for DePIN

DePIN operators run real infrastructure — GPU rigs, storage nodes, wireless hotspots, weather stations, dashcams. But monetizing that infrastructure usually means signing up for a platform, waiting for payouts, and dealing with fiat rails that weren't built for machines.
ClawPurse flips that. Any HTTP endpoint becomes a paid service with one Docker command.
Imagine:

You rent out spare GPU compute for AI inference — agents pay per request, settled on-chain in seconds
You run a sensor network and sell environmental data — 0.001 NTMPI per API call, no subscription required
You host a proxy or VPN exit node — pay-per-session with no account signup
You offer geolocation or mapping data from your fleet — agents query and pay automatically

No payment processor. No platform cut. No waiting 30 days for a bank transfer. Just an HTTP endpoint, a price, and on-chain settlement.
That's the micropayment layer DePIN has been missing — and x402 is the protocol that makes it work.

Resources

x402 landing page: clawpurse.ai/x402
Gateway docs: gateway.clawpurse.ai
Wallet repo: github.com/mhue-ai/ClawPurse
Gateway repo: github.com/mhue-ai/clawpurse-gateway
Agent integration (SKILL.md): github.com/mhue-ai/ClawPurse/blob/main/SKILL.md
Free NTMPI: drip.clawpurse.ai
Tax tracking: ledger.clawpurse.ai
Coinbase x402 spec: x402.org
OpenClaw AI framework: mhue.ai

ClawPurse is open source (MIT) and maintained by the Mhue family. If it's saving you time, tip the builders.

The Internet Was Supposed to Have a Pay Button. ClawPurse Finally Built It — for Machines.

Zach Miller — Sun, 08 Mar 2026 03:13:02 +0000

In 1992, Tim Berners-Lee's team reserved HTTP status code 402 — Payment Required — for "future use." They knew the web would need native payments. They just didn't have the rails.

Three decades later, we got ads. We got subscriptions. We got data harvesting at scale. But we never got the thing the web's architects imagined: a way for one machine to pay another machine, instantly, for a tiny piece of value.

ClawPurse is an open-source micropayment ecosystem on the Neutaro blockchain that finally gives HTTP 402 a real job. A local encrypted wallet, an HTTP reverse proxy that gates any API behind on-chain micropayments, and an agent-friendly faucet — wired together so AI agents can discover a service, pay for it, and get the result without a human ever touching a form.

The code is on GitHub. The sites are live. Here's how it works.

The Stack

ClawPurse Wallet — Self-Custodial Agent Treasury bashnpm install && npm run build && npm link

clawpurse init --password
clawpurse address
clawpurse balance --password
clawpurse send neutaro1... 1.25 --password


**What it is:** A local-only NTMPI wallet with AES-256-GCM encrypted keystores and scrypt key derivation.

**Why it matters for devs:**
- Programmatic API: `send()`, `getBalance()`, `delegate()` — import directly into your agent scripts
- Guardrail wizard: set per-tx spend limits, confirmation thresholds, and destination allowlists before your agent touches real tokens
- Built-in staking: delegate, undelegate, redelegate, track rewards, manage the 22-day unbonding period
- Full audit trail: every send recorded locally with tx hash, block height, memo, and guardrail status

No cloud custody. No third-party key management. Your keys stay on your machine.

**Repo:** [github.com/mhue-ai/ClawPurse](https://github.com/mhue-ai/ClawPurse)

---

### 2. ClawPurse 402 Gateway — Monetize Any API in Minutes

Client (agent/script/browser)
│
├── GET /api/data ──────────────▶ 402 Gateway
│ │
│ ◀── 402 Payment Required ─────────┘
│ { invoiceId, amount, address, memo }
│
├── clawpurse send

--memo
│
├── GET /api/data ──────────────▶ 402 Gateway
│ Header: X-Payment-Proof:
│ │
│ Gateway verifies tx on Neutaro │
│ │
│ ◀── 200 OK (proxied upstream) ────┘

What it is: An HTTP reverse proxy implementing 402 Payment Required. Put it in front of any backend. It handles invoicing, on-chain verification, and proxying.
Two payment flows:
Pay-per-request — each call gets an invoice, client pays on-chain, retries with proof:
pythonimport requests, subprocess

res = requests.get("http://gateway:4020/api/data")

if res.status_code == 402:
inv = res.json()["payment"]
subprocess.run([
"clawpurse", "send",
inv["address"], inv["amount"],
"--memo", inv["memo"], "--yes"
])
res = requests.get(
"http://gateway:4020/api/data",
headers={"X-Payment-Proof": inv["invoiceId"]}
)

data = res.json()
Prepaid balance — deposit once, deduct per call:
bash# Deposit
curl -X POST http://gateway:4020/prepaid/deposit \
-H "Content-Type: application/json" \
-d '{"txHash": "", "clientId": "my-agent"}'

Subsequent requests just use the client ID

curl -H "X-Client-Id: my-agent" http://gateway:4020/api/data
Key features:

Route-level pricing: cheap reads, expensive writes via GATEWAY_ROUTES
SQLite storage, zero external dependencies
One-command deploy: docker compose up
JWT-protected management API for internal wallets and transaction ledger
On-chain verification directly against Neutaro REST API — no oracles, no bridges

bash# Quick start
git clone https://github.com/mhue-ai/clawpurse-gateway.git
cd clawpurse-gateway && npm install
cp .env.example .env
npm run dev
Site: gateway.clawpurse.ai
Repo: github.com/mhue-ai/clawpurse-gateway

Timpi Drip Faucet — PoW Instead of CAPTCHA Timpi Drip replaces CAPTCHA with proof-of-work challenges. ClawPurse ships the PoW solver, so agents can self-onboard with tokens and start transacting immediately. OpenClaw-authenticated agents get higher throughput drip rates. This solves cold start — the chicken-and-egg problem where an agent can't pay for services without tokens, and can't prove it's legitimate if it has to solve a CAPTCHA.

Why This Matters Right Now
The agentic economy went from demos to production in 2025. OpenClaw has 250,000+ GitHub stars. Coinbase open-sourced x402. Mastercard and Visa launched AI agent payment solutions. Deloitte projects $17.5 trillion in autonomous agent commerce by 2030.
But most of that infrastructure targets the biggest chains and enterprise platforms. If you're building on Cosmos, running DePIN nodes, or managing validator infrastructure — the tooling gap is real.
ClawPurse fills that gap for the Neutaro/Timpi ecosystem:
x402 / CoinbaseAgent PlatformsClawPurseChainBase, Solana, AptosMulti-chainNeutaro (Cosmos SDK)CustodyFacilitator-basedPlatform-custodiedSelf-custodial, localTargetEnterprise APIsSaaS buildersDePIN ops, validators, indie devsOnboardingFunded walletPlatform signupPoW faucet, zero signupLicenseOpen sourceProprietary/freemiumMIT
ClawPurse isn't competing with x402. It's implementing the same HTTP 402 pattern for an ecosystem that needs its own rails.

The Business Case in 60 Seconds

No payment processor fees — On-chain settlement to your own wallet. A 0.001 NTMPI request is as viable as a 100 NTMPI request.
Agent-first architecture — Built inside OpenClaw. Machines parse invoices, pay, and retry with proof autonomously.
Programmable guardrails — Spend limits, allowlists, confirmation thresholds. Your agent operates freely within boundaries you set.
DePIN-native — Same CLI manages validator delegations, staking rewards, and API micropayments.
MIT licensed, no lock-in — Fork it, extend it, self-host it. No vendor risk.

Get Started
bash# Wallet
npm install && npm run build && npm link
clawpurse init --password mypass
clawpurse balance --password mypass

Gateway

git clone https://github.com/mhue-ai/clawpurse-gateway.git
cd clawpurse-gateway && npm install
cp .env.example .env && npm run dev

Test the 402 flow

curl http://localhost:4020/api/test
Links:

🌐 clawpurse.ai — Main platform
🔀 gateway.clawpurse.ai — 402 Gateway
💧 drip.clawpurse.ai — Drip Faucet
📦 Wallet repo
📦 Gateway repo
🤖 SKILL.md — Agent integration docs

The internet finally has its pay button. The question is what you'll build behind it.
Explore ClawPurse