Under the hood

oculr is machine-payments native. You pay oculr over MPP - and oculr buys its on-chain data, web research, and compute the same way, per request. You never hold an API key, and everything oculr spends on your analysis is accounted per request.

The self-funding loop

When your payment settles, part of it immediately funds the upstream work for your analysis:

You (your wallet)
   │  MPP session - metered vouchers, USDC.e on Tempo
   ▼
oculr API
   │  MPP charges & sessions, per request
   ├──▶ RPC provider        - transaction traces (50+ EVM mainnets)
   ├──▶ Blockchain database - decoded history, wallet activity, SQL
   ├──▶ Web research        - novel protocols, incident context
   ├──▶ Code execution      - sandboxed calldata & bytecode analysis
   ├──▶ Price data          - token prices, USD values
   │
   │  usage-based billing, metered per token
   └──▶ LLM inference       - the analysis agent itself

This is why oculr needs no accounts and no signup: there is no platform subscription being amortised across users. Each request buys exactly the work it needs, and the metered price you pay reflects that cost.

What gets bought per request

Every analysis draws from a mix of paid MPP services and free public infrastructure. The paid calls are what you see itemised in the costs buckets on your response.

Paid over MPP

Supplier role	What oculr buys	`costs` bucket
Trace providers	`debug_traceTransaction` call trees, receipts, bytecode across 50+ mainnets	`dataCollection`
Blockchain databases	Decoded transaction history, wallet activity, address labels	`dataCollection`
Web research	Search + page extraction when the agent meets a novel protocol or fresh incident	`dataCollection`
Price data	Token prices and market data for USD valuation	`dataCollection`
Code execution	Sandboxed environment for calldata decoding and bytecode analysis	`codeExecution`

LLM inference

The agent's reasoning tokens are the dominant cost of most analyses. Inference is billed usage-based with the model provider - metered per token, with prompt-cache discounts passed through - and lands in the llms bucket at exactly what your run consumed. Same per-request accounting, different payment rail.

Free public infrastructure

Not everything costs money. oculr prefers free, keyless sources when they're as good:

Block explorers - decoded token transfers and ERC-4337 UserOperations, keyless.
Signature databases - function selector and event topic lookups for every frame in the call tree.
Multisig services - multisig context when a Gnosis Safe appears in the trace.
Local decompilation - Solidity reconstruction for unverified contracts.

For address labels, the free source is tried first: a block explorer answers instantly, and a paid database is queried only when the explorer has nothing.

Verified contract source is the one exception to keyless-first. It draws on the Etherscan API (which needs a key, though its tier is free) for its coverage - especially across chains - with keyless explorers (Blockscout, Sourcify, and explorer HTML) as fallback, and local decompilation when no verified source exists anywhere.

Adaptive spend

The agent decides per transaction which tools to invoke, so upstream spend tracks transaction complexity:

A simple transfer needs a trace, a couple of label lookups, and a short agent loop - a handful of sub-cent calls.
A multi-protocol DeFi transaction adds price lookups, decoded history, and more agent iterations.
A novel exploit can trigger web research, contract decompilation, sandboxed re-analysis of calldata, and a long agent loop.

You can watch this happen live: in SSE mode, each tool_call event is the agent buying one of the resources above, and the final result event carries the full costs breakdown.

Why this architecture

Running the supply chain on per-request payments instead of platform subscriptions has three customer-visible consequences:

True metered pricing. oculr's costs are per-request, so your price can be too. There's no monthly platform fee being recovered from you.
Full cost transparency. Because every upstream call is individually paid or metered, every upstream call is individually accounted - that's what makes the costs breakdown on your response exact rather than estimated.
No key for you to manage. Your side of the relationship is a funded wallet and a protocol - no signup, no oculr API key to store, rotate, or leak.

Pricing - the metered formula and real production costs
Core concepts - the analysis pipeline these suppliers feed
Glossary - MPP, sessions, vouchers, and the rest of the vocabulary