The clearing house for
the agentic economy

4Mica gives agents one place to pay on credit, earn yield, and settle transactions without clearing every request on-chain.

Start building See how it works

Supported on Base, Ethereum Sepolia, and Base Sepolia

The real cost

Agentic economy breaks at scale.

1M API calls, 10k USDC volume, 1 year.

x402

per-transaction settlement

Capital locked in wallet

earns 0%, just sitting there

$10,000 USDC

Yield earned

no yield mechanism

Gas fees paid (1M on-chain txs)

~$0.001 × 1,000,000 settlements

+$1,000 USDC

Time waiting for finality

1M txs × ~1 s avg block time

278 hours

Total cost$11,000 USDC

With 4Mica

credit layer + batch settlement

Capital deployed in Aave vault

non-custodial · withdraw anytime

$10,000 USDC

Yield earned over 1 year

~5% Aave USDC APY

+$500 USDC

Gas fees

batch + netting · sponsored · $0 for payer

< $1

Time waiting for finality

10ms BLS signature + verification per request

2.7 hours

Net cost$9,500 USDC

Same 1M calls. Same starting capital.

$1,500 saved/275.3 hours reclaimed

How it works

Separate payment authorization from settlement

Pay with programmable cryptographic credit. Settle thousands of payments in one on-chain transaction.

01Deposit

Deposit collateral once

Funds go into Aave and earn yield. A single collateral deposit covers all credit.

await client.user.approveErc20(usdc.address, AMOUNT);
await client.user.deposit(AMOUNT, usdc.address);

02Spend

Spend on credit: instant, off-chain

The agent signs an EIP-712 guarantee claim and receives BLS-signed credit. No gas, no chain transaction. Verified in milliseconds.

const payment = await signGuarantee({
  cycleId:   "0xabc",  
  reqId:     "0x0",
  amount:    "0x64",
  recipient: "0x72e1…ResourceHub",
});

// GET /resource
// X-PAYMENT: <base64(payment)>
// HTTP 200 OK

03Netting

Netting across the cycle

Every 7 days the cycle closes. Bilateral flows collapse into one net position per participant.

// Cycle closes every 7 days, netting begins
// Bilateral edges this cycle:
Alice → Bob:  800 USDC  (40 guarantees)
Bob → Alice:  300 USDC  (15 guarantees)
// net_debit[Alice]  = max(800 - 300, 0) = 500 USDC
// net_credit[Bob]   = 500 USDC
// 55 guarantees turns into 1 net position per participant

04Settle

Settle on-chain, one net payment

Net debtors pay once. Creditors claim once. Defaults are covered by vault collateral.

// Debtor pays net position to ClearingHouse
await clearingHouse.payNetDebit(
  cycleId,
  netDebit,       // 500 USDC (not 800)
  merkleProof,
);

// Creditor claims once debtor has paid
await clearingHouse.claimNetCredit(
  cycleId,
  netCredit,
  merkleProof,
);

// 55 off-chain payments → 1 on-chain settlement

Same x402 protocol. Same HTTP clients.

Replace thousands of transactions/one net settlement per cycle

Use cases

Built for the scale you need

API monetization, agentic commerce, paywalled content. 4Mica handles the payment layer so you don't have to.

AI Agents

Agents pay APIs on credit, settle once

An AI agent calls dozens of endpoints per task: data feeds, inference, storage. No account setup, no API keys. It pays on credit from one pool and settles net exposure once per epoch.

No account setupInstant onboardingAuto-settlement

Agentic Commerce

Agent-to-agent micropayments at scale

When agents transact with each other at high frequency, on-chain settlement per call is unworkable. 4Mica natively nets bilateral flows and collapses them into one settlement.

Agent-to-agentBilateral nettingHigh-frequency

API Monetization

Accept payments with one line of code

Add 4Mica middleware and charge per HTTP request. Works with any x402-compatible client. No SDK on the client side, no KYC, no credits to manage. Money moves at the speed of the internet.

x402-compatibleAny HTTP clientZero friction

Financial Infrastructure

Clearinghouse for on-chain apps

Build a payment rail that aggregates millions of micro-transfers, earns yield on float, and settles net positions on-chain. The same primitive that banks use, but permissionless.

Yield on floatProgrammable disputesNon-custodial

Ecosystem

Built on primitives you already trust

4Mica is not a new protocol stack. It is a credit layer on top of production infrastructure.

x402Payment protocol

The HTTP payment standard 4Mica extends with a credit layer. Any x402-compatible client works out of the box.

AaveYield layer

All collateral routes directly to Aave. Deposits earn APY continuously. Your payment infrastructure generates returns.

Ethereum / BaseSettlement layer

Net positions settle on-chain via EVM-compatible contracts. One transaction per settlement window, cryptographically enforced.

Non-custodial

You own your collateral. 4Mica never holds funds.

Open-source core

Contracts and SDKs are public on GitHub.

Testnet live

Deposit, spend, and earn on Sepolia today.

Teams building on 4Mica

Trusted by fast-growing companies around the world.

Get started

View on GitHub

Integration

3 lines to enable credit-based payments

Works with your existing HTTP client. No contract changes. No new wallet. Fully x402-compatible.

agent / client · typescript

import { FourMicaEvmScheme } from "@4mica/x402/client";
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { privateKeyToAccount } from "viem/accounts";

// 1. Create your account
const account = privateKeyToAccount("0xYourPrivateKey");
// 2. Register the 4Mica credit scheme
const scheme = await FourMicaEvmScheme.create(account);
// 3. Wrap your existing fetch. That's it.
const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:84532", client: scheme }],
});

// Now every request is credit-based. No gas, no chain.
const response = await fetchWithPayment("https://api.example.com/data");

SDKs are availableAvailable now in TypeScript & Python · Rust coming soon

FAQ

Common questions

Standard x402 settles every payment on-chain, one transaction per request. 4Mica adds a credit layer: agents sign off-chain guarantees and spend against pooled collateral. Settlements are batched and happen once per window, resulting in orders of magnitude fewer transactions.

A tab is a credit session opened by the recipient (POST /tabs). It has a tabId, TTL, and version. Individual spends within the tab are identified by a reqId that increments with each signed guarantee.

A payment guarantee is an EIP-712 signed claim that the payer attaches as an X-PAYMENT header. It commits to tabId, reqId, amounts, addresses, and timestamp. The facilitator verifies the signature and issues a BLS-signed certificate for on-chain settlement.

Stablecoin deposits route through Aave via depositStablecoin(). The protocol holds aTokens on your behalf. APY accrues continuously and offsets the cost of payments.

Users call payTabInERC20Token() after 7 days. If they don't, the recipient's on-chain claim window opens at day 14 (remunerationGracePeriod) and closes at day 21 (tabExpirationTime).

V2 guarantees use ERC-8004's ValidationRegistry. The payer signs a guarantee committing to a specific validator, agent, score threshold, and job hash. If the validation fails on-chain, remunerate() reverts and collateral stays locked. Validators post a 0–100 score on-chain.

Call requestWithdrawal() to start the timelock, then finalizeWithdrawal() after the withdrawalGracePeriod (default 22 days). A 6-hour synchronizationDelay prevents race conditions with open tabs.

ETH and stablecoins. USDC and USDT are enabled by default. Other ERC-20s can be configured by the operator.

Yes. 4Mica is x402-compatible. Wrap your existing fetch or requests client with the 4Mica scheme adapter. One line of code. No changes to your server or HTTP logic.

Something else on your mind?Contact us

Start building

Stop paying per transaction.

Batch thousands of payments, settle once, and let your collateral earn yield while your agents scale.

1 txper settlement

~0gas per call

APYon collateral

Start building View Source

The clearing house forthe agentic economy