Pay once for an AI answer. Every agent reuses it.
arcapis is the shared, on-chain cache for AI agents on Arc.
Call any AI API and pay per request in USDC — repeated answers come back free. No subscriptions, no API keys, no signup.
Pick an API
LLMs, image generation, TTS, embeddings, scraping. Each endpoint is on-chain in EndpointRegistry with a fixed USDC price.
Mint a packet NFT
Sign a USDC transfer — PacketContract mints an ERC-721 packet bound to your wallet, with the purchased quota baked in. Under a second on Arc testnet.
Call from anywhere
Your packet has a permanent URL. Call it from any agent or script — gateway verifies ownership on-chain, no API key needed.
Call AI APIs through one consistent gateway.
Use the same URL pattern, same payment flow, same response shape — across every supported AI service. OpenAI, Anthropic, Google, Stability, ElevenLabs, and more.
One shape, every service.
Pay once for a packet, get a private URL, then call it like any HTTP API. No keys to rotate, no plans to negotiate.
Approve & buy on-chain
Approve USDC, then mint a packet directly on PacketContract. Each packet is an ERC-721 token bound to your wallet.
usdc.approve(packet, price × qty) packet.buyPacket(endpointId, qty) → tokenId (emit PacketBought)
Read your packet
Anyone can verify your packet on Arc testnet — buyer, price, and endpoint are all on-chain. Live quota is metered by the gateway.
packet.getPacket(tokenId) → { endpointId, callsRemaining, buyer, pricePaid }
Call any service
Hit the gateway with your tokenId. It verifies ownership on-chain, checks the shared cache first — a repeat returns free — then forwards upstream on a miss and caches the answer for the next agent.
POST /api/call/123 Content-Type: application/json { "prompt": "Hello" }
Connect your wallet.
Arcapis runs on Arc testnet — Circle's stablecoin-native L1 where USDC is the native gas token. Connect MetaMask to start. Other wallets coming soon.
Choose a wallet to continue
Arcapis currently supports MetaMask on Arc testnet. More wallets are coming soon.
Need testnet USDC?
You need USDC on Arc testnet to pay for API calls. The Circle faucet drips 20 USDC every 2 hours per address.
Open Circle faucetPay-per-call APIs.
Pick an endpoint, set quantity, and pay in USDC. Each call costs a fixed fee (set per endpoint) plus Arc network gas. Calls fail if your wallet has insufficient balance.
TREASURY_ADDRESS in Netlify env vars (or in x402-challenge.js)
before going live, or test payments will go to a placeholder address.
Select an endpoint to begin.
Transaction history.
Every payment you sign for an Arcapis endpoint shows up here. Data is fetched live from Arc testnet — click any tx hash to view the on-chain receipt.
Your packets.
Each successful payment unlocks a packet — a private URL you can call until the purchased quota runs out. Copy the URL into your agent or curl it directly.
Wrap your own API.
Point us at your existing HTTP API. We mint a paywalled endpoint on Arc, route calls, verify payments, and pay you out in USDC. You set the price.
Bring your own endpoint.
Self-serve provider onboarding: drop in a YAML spec or an OpenAPI URL, set your price, and we ship an arcapis.dev endpoint that handles billing, gas, and payouts in USDC.
Packet marketplace.
Quota is an ERC-721 — so unused quota is sellable. List a packet you no longer need, or buy someone's remainder at a discount. Remaining calls travel with the NFT.
Resell the calls you don't need.
Fixed-price listings settled atomically in USDC: the packet NFT moves to the buyer and the seller is paid in the same transaction. The old call key revokes itself the moment ownership changes — the gateway re-checks the owner on every call.
Developer docs.
Buy a prepaid USDC packet, call any endpoint with per-call EIP-712 auth, and let the cross-agent cache make repeat queries free. Everything settles in USDC on Arc Testnet.
A pay-per-call gateway for AI APIs on Arc. You buy a packet — an ERC-721 NFT that represents N prepaid calls to one endpoint — then your agent calls through the gateway. Two things set it apart from a plain API key:
1. Per-call EIP-712 auth. Every request carries a fresh signature instead of a
long-lived bearer token, so a leaked signature risks one call, not your whole quota.
2. A cross-agent cache. Cacheable results are pinned to IPFS and shared across
every agent — the first caller pays, everyone after reuses it free.
1. Buy a packet on the Buy APIs page (mint an NFT with quota). 2. Install the SDK. 3. Call.
npm i @manhcuongsev/arcapis-sdk ethers
import { ArcApis } from '@manhcuongsev/arcapis-sdk';
import { Wallet } from 'ethers';
const arc = new ArcApis({
signer: new Wallet(process.env.AGENT_PRIVATE_KEY),
packetTokenId: 5, // the packet you just bought
});
const r = await arc.call('embed', { input: 'hello agentic economy' });
if (r._cached) {
console.log('FREE — cache hit, quota unchanged');
} else {
console.log('PAID — quota now', r.calls_remaining);
}
No build step? Sign the EIP-712 message yourself and POST /api/call/<packetId>. The full message format is in the SDK source on GitHub.
The cache key is keccak256(endpointId + body) — the packet ID is deliberately
excluded, so a result one agent paid for is reused by every agent. The first agent to
embed "summarise CCTP v2" pays; everyone after gets the same vector free until it expires.
| Category | Cache TTL | Why |
|---|---|---|
| VECTOR | 30 days | Embeddings are deterministic |
| DATA | 30 min | Scrape data updates slowly |
| LLM / IMAGE / AUDIO | never | Per-prompt / creative output — always fresh |
A cache hit returns the same shape as a paid call, plus a _cached block and an unchanged calls_remaining:
{
"endpoint": "embed",
"calls_remaining": 5, // unchanged on a hit
"result": { /* upstream body, fetched from IPFS */ },
"_cached": { "hit": true, "age_seconds": 18, "ttl_seconds": 2592000, "cid": "bafkrei…" }
}
Catalogue with per-call price. Live availability (and demo badges for endpoints without an upstream key) is shown on the Buy APIs page.
| ID | Name | Category | Price / call |
|---|---|---|---|
| gpt5 | OpenAI GPT-5 chat | LLM | $0.003 |
| claude | Claude Opus 4.7 | LLM | $0.004 |
| gemini | Gemini 2.5 Pro | LLM | $0.0025 |
| embed | OpenAI embeddings | VECTOR | $0.0008 |
| whisper | Whisper transcribe | AUDIO | $0.03 |
| scrape | Bright Data scrape | DATA | $0.002 |
| image | DALL·E image | IMAGE | $0.10 |
| sdxl | Stable Diffusion XL | IMAGE | $0.08 |
| tts | ElevenLabs TTS | AUDIO | $0.05 |
Per-call EIP-712 (recommended). Each request signs a message binding
packetId + endpointId + bodyHash + nonce + validUntil. A leaked signature is good
for one call, not the whole packet. The SDK does this automatically.
Bearer (legacy). Authorization: Bearer ak_… still works server-side for
older clients, but a leaked key drains the full quota until revoked — prefer EIP-712.
| Contract | Address | Role |
|---|---|---|
| EndpointRegistry | 0x417694A53666E62d058cAa35eB85cFCacBC28965 | API catalogue (anyone can register) |
| PacketContract | 0xB7B66bC873A4e9D415c1C4C4a8876AEC3892f798 | ERC-721 prepaid quota |
| CacheRegistry | 0xD06d70f356FF0ceC32582FB06177e163dBA76e02 | queryHash → IPFS CID |
| USDC | 0x3600000000000000000000000000000000000000 | Settlement asset (native gas on Arc) |
✓ All contracts are source-verified on ArcScan — read the code and live state at testnet.arcscan.app.
Full SDK reference, the EIP-712 message format, and the reference research-bot example are on
GitHub.
SDK package: @manhcuongsev/arcapis-sdk.