Pricing

ICME uses pay-per-use pricing. There are no subscriptions, no seats, no monthly minimums. You pay for what you use, when you use it.

What things cost

	Credits	USD
Compile a policy (/v1/makeRules)	300 credits	$3.00 one-time per policy
Check an action (/v1/checkIt)	1 credit	$0.01 per check
Check without an account (/v1/verifyPaid)	—	$0.10 per check
Third-party check against your policy	—	$0.10 per check (paid by the requester)

1 credit = $0.01. Policy compilation is a one-time cost, once compiled, a policy is reusable indefinitely.

How to pay

ICME supports two payment methods: card and crypto. Both give you the same credits at the same price. Creating an account gives 325 free credits to try it out!

Pay with card

No crypto wallet required. Use any credit or debit card via Stripe Checkout.

Create an account:

Open the checkout_url in your browser, pay with card, then retrieve your API key:

curl -s -X POST https://api.icme.io/v1/createUserCard \
  -H 'Content-Type: application/json' \
  -d '{"username": "YOUR_USERNAME"}' | jq .
# Returns checkout_url — open in your browser and pay $5.00 by card
# Then retrieve your API key. Via curl or by opening link in browser.
curl -s https://api.icme.io/v1/session/SESSION_ID | jq .

Top up credits:

Open the checkout_url, pay with card, then confirm:

bash

curl -s -X POST https://api.icme.io/v1/topUpCard \
  -H 'Content-Type: application/json' \
  -H 'X-API-Key: YOUR_API_KEY' \
  -d '{"amount_usd": 10}' | jq .
# Returns checkout_url — open in your browser and pay by card
# Then confirm credits:
curl -s https://api.icme.io/v1/session/SESSION_ID | jq .

Pay with USDC on Base

For teams that prefer crypto, or for autonomous agents that pay for themselves.

Create an account:

curl -s -X POST https://api.icme.io/v1/createUser \
  -H 'Content-Type: application/json' \
  -d '{"username": "YOUR_USERNAME"}' | jq .

Top up credits:

curl -s -X POST https://api.icme.io/v1/topUp \
  -H 'Content-Type: application/json' \
  -H 'X-API-Key: YOUR_API_KEY' \
  -d '{"amount_usd": 10}' | jq .

Credit tiers

Deposit	Credits	Bonus	Checks
$5	500	—	500
$10	1,050	+5%	1,050
$25	2,750	+10%	2,750
$50	5,750	+15%	5,750
$100	12,000	+20%	12,000

Larger deposits get a bonus. Credits don't expire.

Try before you pay

You don't need an account to try ICME. Use /v1/verifyPaid with the live demo policy — $0.10 per check, no registration required.

curl -s -X POST https://api.icme.io/v1/verifyPaid \
  -H 'Content-Type: application/json' \
  -d '{
    "policy_id": "f6e3cd15-9e28-45c4-9f4c-683edd63e468",
    "action": "Send 1000 USDC to an unknown wallet."
  }' | jq .

This runs a live check against a real compiled policy and returns a real SAT/UNSAT result.

Why not just use an LLM to check actions?

Most teams start by prompting a model to evaluate whether an agent's action is safe. It works in demos. In production it has three problems.

It's probabilistic, not provable. The same action can pass one run and fail the next. You can't unit test it, cache it reliably, or audit it. There is no mathematical guarantee, only a confidence score.

It's gameable. A sufficiently crafted input can convince an LLM judge that a policy-violating action is acceptable. Formal verification doesn't have this surface area. The SMT solver either finds a satisfying assignment or it doesn't. There is no prompt that makes UNSAT return SAT.

It produces no receipt. When an autonomous agent executes a transaction, you may need to prove after the fact that the action was authorized. An LLM returning "approved" is not an audit trail. A zero-knowledge proof is.

ICME costs $0.01 per check. A GPT-4o-mini call for guardrail evaluation costs roughly $0.001–$0.005 — ICME is more expensive. The question is whether you need a proof or a prediction.

Why use x402?

Agents don't have credit cards. If your AI agent needs to check an action against a policy, it should be able to pay for that check autonomously — without a human topping up a billing account. The x402 + USDC model makes this native. Your agent detects a 402, executes the payment, and retries. No human in the loop.

No lock-in. You're not committed to a monthly plan. Load credits when you need them, use them when you need them. If you stop using ICME, you stop paying.

Consistent with our trust model. ICME is built on the premise that you shouldn't have to trust a provider — you should be able to verify. Blockchain-settled payments are transparent and auditable.

What is USDC?

USDC (USD Coin) is a stablecoin pegged 1:1 to the US dollar. $1.00 USDC is always worth $1.00. It is issued by Circle and is one of the most widely used digital currencies for developer payments.

Unlike volatile cryptocurrencies, USDC doesn't fluctuate in value. When you send $3.00 USDC to compile a policy, you're sending exactly $3.00.

What is Base?

Base is a blockchain network built by Coinbase. It is fast, cheap, and designed for everyday transactions — sending $0.01 USDC on Base costs a fraction of a cent in gas fees.

ICME uses Base because it makes micropayments practical. Paying $0.01 per guardrail check only makes sense if the transaction fee doesn't exceed the cost of the check itself. On Base, it doesn't.

How to get USDC on Base

Option 1: Coinbase (easiest) — Create an account at coinbase.com, buy USDC with a bank transfer or debit card, then send to your wallet address selecting Base as the network.

Option 2: Bridge from another network — If you hold USDC on Ethereum mainnet or another chain, use the Base Bridge to move it to Base. Takes ~5 minutes.

Option 3: Exchange withdrawal — Most major exchanges (Kraken, Binance, Bybit) support withdrawals directly to Base. Buy USDC and withdraw to the Base network.

Any Ethereum-compatible wallet works: MetaMask, Coinbase Wallet, Rainbow, or any wallet that supports Base. For programmatic integration, viem, ethers.js, web3.py, or the Coinbase Developer Platform SDK all work.