Your agent pays.Warns decides first.

For teams whose agents pay for APIs over x402. Each payment is checked against your rules before it is signed.

1.88 USDC

paid by an x402 client without Warns

0.01 USDC

paid by the same client with Warns

98%

of EIP-3009 payments on Base under 1 USD, the x402 client default cap

Four traps.See what your agent signs.

1. Point your agent at them

They speak x402 on Base Sepolia and behave like a compromised merchant. Use the client you already have.

2. See what it paid

Every payment it signed is listed with its transaction. An unprotected client pays all four, because each one stays under its 1 USD default cap.

3. Wrap it and run again

Add Warns to your x402 client. The honest price goes through; the traps are blocked or held for a human.

Why a spend capis not a security layer.

26.4 M payments in 90 days

115 M USDC settled on Base through EIP-3009 authorizations, the primitive x402 uses. 184,000 payers.

Median payment: 0.006 USD

Nine payments in ten are under ten cents. A merchant can charge a hundred times its price and nobody notices.

98% under the default cap

The x402 client (@x402/core 2.26) ships with a 1 USD default cap per payment. 98 payments out of 100 on Base fit under it, and so does every trap above.

A decision beforethe signature.

The payment is evaluated first

The guard reads the 402, normalizes what the merchant asks, and sends it to the decision service with what your agent meant to buy. The answer comes back signed.

The signer refuses the rest

Only an authorization that matches an approved decision gets signed. When your agent signs through the signer Warns wraps, a payment that goes around the guarded fetch cannot be signed either.

The chain is the last judge

Every transfer leaving your agent's wallets is reconciled against the decisions. One that bypassed Warns is flagged and the agent is frozen: Warns approves nothing more until someone looks.

Protect an agentwith the client you have.

Replace the fetch you pass to the x402 client. You need a Warns key, an agent id and the signer your agent already uses, which stays yours. Start in monitor mode: nothing is blocked until you switch to protect.

guard.ts

import { createGuard } from "@warns/sdk"

const guard = createGuard({
  apiKey: process.env.WARNS_KEY,
  agentId: "research-agent",
  baseUrl: "https://api.warns.xyz",
  rootAddress: "0xA26aa29cF9b429AD85E7a0F7FA6aBd8edE301e8a",
})

const pay = guard.x402Fetch(signer, {
  intent: () => ({ expectedMaxUsd: 0.05, purpose: "market-data" }),
})

await pay("https://data.vendor.com/quote")  // pays, holds, or throws with the reason

What is enforced today,and what comes next.

SDK control, today

The SDK checks each payment before signing, and the signer it wraps refuses what was not approved. Stops a merchant, a bad dependency or an injected instruction from making your agent pay, as long as the agent signs through Warns.

Onchain detection, today

Reconciliation flags any payment from your agent's wallets that skipped a decision, and freezes the agent: Warns approves nothing more until someone looks. It detects after the fact and does not stop a key used elsewhere, but a bypass never goes unseen.

Signer-bound checks, next

The key itself checks the decision before signing, inside the wallet or the enclave. Nothing leaves without a decision, even if code holds the raw key. This is where the roadmap goes.

Protect your agents.Get early access.

Early access is for teams whose agents pay for APIs over x402 on Base. Or test your agents right now.