# Pricing

### What things cost

| Action                                                                                                                                      | Credits     | Cost                                    |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | --------------------------------------- |
| Compile a policy (`/v1/makeRules`)                                                                                                          | 300 credits | $3.00 one-time per policy               |
| Screen an action (`/v1/checkRelevance`)                                                                                                     | —           | **Free**                                |
| Takes a tool call and explains what it does in plain english; things like "rm -f". It also provides a free relevance check. (`/v1/explain`) | —           | **Free**                                |
| Check an action (`/v1/checkIt`)                                                                                                             | 1 credit    | $0.01 per check                         |
| Check with an account on x402 (`/v1/checkItPaid`)                                                                                           | —           | $0.10 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) |
| <p>See if an action has anything to do with your policy.<br>(<code>/v1/checkRelevance</code>)</p>                                           | —           | **Free**                                |

1 credit = $0.01. Policy compilation is a one-time cost. Once compiled, a policy is reusable indefinitely. \
\
**The `checkRelevance` endpoint is free. It should be used to check an agent action before running a full `checkIt` call depending on use-case.** If the action is relevant, or if you other tests / guardrails trigger use checkIt.

### 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:

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

Open the checkout\_url in your browser, pay with card, then retrieve your API key:

```bash
curl -s https://api.icme.io/v1/session/SESSION_ID | jq .
```

Top up credits:

```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 .
```

Open the checkout\_url, pay with card, then confirm:

```bash
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:

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

Top up credits:

```bash
curl -s -X POST https://api.icme.io/v1/topUp \
  -H "X-API-Key: YOUR_API_KEY" | 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.

### Reduce costs with relevance screening

Most agent actions don't touch your policy. Reading files, formatting text, summarizing content — none of these need a paid check. `checkRelevance` screens every action for free before you spend a credit on `checkIt`.

In a typical agent session, 80-90% of actions return `should_check: false` and skip the paid check entirely. For an agent running 1,000 actions per day, that's 100-200 paid checks instead of 1,000.

`checkRelevance` requires an API key to load your policy but does not deduct credits. See [Relevance Screening](https://docs.icme.io/documentation/learning/relevance-screening) for the full API reference.

### 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.

```bash
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 about 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.icme.io/documentation/getting-started/pricing.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.