Pricing

oculr is metered: you pay for the actual cost of analysing your transaction. No subscriptions, no tiers, no API keys - every request settles over MPP in USDC.e on Tempo.

What you pay

You're charged for exactly the work your transaction needs - LLM reasoning, trace fetches, address labels, token prices, web research, code execution. A simple transfer touches a handful of upstream services; a deep exploit investigation runs many more tool calls and burns far more tokens, so it costs more.

Charges settle in $0.01 increments as the analysis runs - you never prepay for work that didn't happen, and there's no flat quote to overshoot.

The two endpoints bill at different granularity:

• Sync POST /explain (SSE) - metered exactly. You pay your specific analysis's cost, signed incrementally as it runs.
• Async POST /explain/async - collected across the job lifecycle. Submitting charges $0.01; each GET /result/:jobId poll collects what the analysis has accrued since your previous poll; the first poll after the job finishes charges the true-up. The cumulative total is identical to the sync SSE price for the same analysis. A poll with nothing yet to collect is free, as are subsequent fetches of an already-paid finished result. Failed jobs true up the same way. Keep polling with a paying client: 90 seconds with nothing collected aborts the run and leaves a partial result.

What analyses cost

Costs cluster into two bands, and most analyses land clearly in one or the other:

• Routine work - transfers, swaps, straightforward DeFi - runs roughly $1 to $2.
• Incident and exploit investigations - many more tool calls over far more data - usually around $3-4.

There is very little in between, so an "average" is misleading: the median of the whole set sits in a gap that few individual analyses actually occupy.

For reference, the distribution across 48 production analyses to 2026-07-29 on the default model (claude-opus-5), at the contract price:

Size your deposit against the top of the range, not the median. One analysis in ten costs more than $8.06 - which is why the suggested deposit is $16.

Two honest caveats about that table. It is drawn from oculr's own benchmark corpus, not from customer traffic: 48 analyses over 24 distinct transactions, deliberately weighted toward hard exploit cases because those are what the service is built for. And it is a small sample - it describes what we have measured, not a guaranteed bound. Your own mix will decide which band you mostly sit in.

What kind of transaction it is

What kind of transaction you send explains much of that spread, though not all of it. Joining production charges to the benchmark corpus by transaction hash prices each class of work directly:

Read the two count columns before the prices. Analyses is how many paid runs went into the cell; distinct txs is how many different transactions those runs covered. Three runs over one transaction is one transaction priced three times, not a market rate - so the thin rows quote no typical figure at all rather than dressing up a median over three runs. Even the fullest cell rests on four transactions.

What the table does support:

• Benign transactions are the cheapest class by median. Four ordinary mainnet transactions - a DEX aggregator swap, an Aave liquidation, a bridge deposit, an NFT mint - at a median of $1.82. That is the routine band, measured rather than assumed. But $1 to $2 is not a ceiling for routine work: one of those four ran to $4.40.
• In aggregate an exploit costs roughly twice a control. Across all 36 exploit analyses the median is $3.95, against $1.82 for the 7 controls. Class by class it is noisier than that summary suggests: reentrancy and rounding both sit inside a tight $2.89-$4.60, while oracle manipulation runs from $0.11 to $9.38.
• Bridge and cross-chain message validation is the most expensive well-populated class - a $6.29 median over 9 runs across 4 transactions, the highest median of any cell with enough runs to quote one.
• The spread inside a class is real, and it is not something you can plan around. The same Lumi Finance transaction billed $1.45 and $1.73 on two runs - and several times that on a third, a one-off outlier. How deep an investigation goes varies run to run, so treat a class median as a centre of gravity, never as a quote.

Same population and method as the distribution above: production runs on claude-opus-5, at the contract price, to 2026-07-29, deduped by request. 43 of the 50 production analyses recorded in that window ran on a corpus transaction and are in this table; the other 7 ran on ad-hoc test transactions with no attack type to report. (The distribution above is n=48 because it was computed just before the last two runs of 2026-07-29 landed.)

Regenerate rather than edit: npx tsx --env-file=.env scripts/pricing-by-attack-type.ts.

Choosing a cheaper model

Model reasoning is roughly half the bill - measured at 48% of the charge against 51% for data collection, across the 15 recorded production runs. The rest (traces, labels, prices) does not change with the model, so a cheaper model cuts at most about half your cost, not all of it. Pass a model field on the request body to trade accuracy for cost:

Those ratios are per-token list prices ($5/$25 per Mtok for Opus, $3/$15 for Sonnet, $1/$5 for Haiku). Applied to a ~48% LLM share, Sonnet saves roughly 20% of the total bill and Haiku roughly 40% - substantial, but nothing like the per-token ratio on its own suggests.

This list is the server's actual allowlist (ALLOWED_MODELS); any other value is rejected. GET /tool-spec.json publishes the live default in its defaultModel field if you'd rather read it programmatically than trust this page.

How metering works

Sync analyses use MPP metered sessions - the streamed-payments variant of the protocol's session intent:

1. Your client opens a payment channel against the API with a maxDeposit cap.
2. As the analysis accrues cost, the server requests $0.01 voucher increments so your cumulative payment tracks the running cost. The session client signs them automatically mid-stream - no interaction.
3. The final increment settles the balance, and the result is released.

Two properties fall out of this design:

• You never prepay for work that didn't happen. If an analysis is cheap, you pay a cheap price. There is no flat quote to overshoot.
• Your hard spend cap is maxDeposit. The server can never charge past the channel deposit, and your client will never sign past maxDeposit. It is a ceiling, not the amount you escrow - so give it real headroom above your most expensive expected analysis, since an exploit investigation can run to several dollars. See The channel deposit for why it must sit above the suggested deposit rather than on it.

The channel deposit

Opening a channel escrows a deposit. Every 402 from oculr advertises a suggestedDeposit of $16, and your client opens at min(suggestedDeposit, maxDeposit).

The deposit is escrow, not a charge. You are still billed only for the analysis you actually run, and every unspent cent of the deposit returns to your wallet when the channel closes. A $16 deposit on a $1.20 analysis means $1.20 spent and $14.80 refunded, not $16 spent.

Size it above your analysis, not below. Once cumulative spend reaches the deposit, your client has to raise it on-chain, mid-analysis, and mppx tops up by only the shortfall - so with $0.01 metering, a deposit that runs out turns every remaining cent into its own transaction while the stream waits. $16 clears every production analysis on record, but the hardest cases come within a few dollars of it - treat $16 as the floor for a session that might hit a hard case, not as generous headroom.

Set maxDeposit above the suggestion, not equal to it. maxDeposit is a ceiling, not escrow - the channel still opens at $16 (the smaller of the two), so a higher cap costs you nothing up front. But set it on $16 and the channel can never grow: mppx won't sign past the ceiling, so a session that later needs more - a second analysis on the same channel, or a hard case near the top of the range - fails mid-run with no result. Use '32' - it escrows the same $16, with headroom for the hardest cases and a second analysis on one channel.

Raise a deposit deliberately between runs with a single session.topUp(), or close the channel (unspent funds come back) and open a fresh one - don't let one run drift past its deposit into per-cent top-ups mid-stream.

import { tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'
 
const account = privateKeyToAccount(process.env.WALLET_PRIVATE_KEY as `0x${string}`)
// Two different numbers, on purpose. The channel opens at
// min(suggestedDeposit, maxDeposit) = $16 - that is what gets escrowed, and
// whatever you don't spend is refunded on close. maxDeposit is the signing
// ceiling: '32' leaves the channel room to be topped up later. Equal to the
// suggestion it could never grow at all, and the second heavy run would die
// mid-stream.
const session = tempo.session.manager({ account, maxDeposit: '32' })
// session.sse('https://mpp.oculr.xyz/explain', …) - see the quickstart for the full call.

Because metering rides the stream, incremental vouchers apply to the SSE endpoint. The async endpoint reaches the same total through the classic Mppx.create() + fetch() flow: $0.01 at submit, then one charge per poll for whatever accrued since the previous one, and a true-up on the first poll after the job finishes. Full recipes for both: Call the oculr MPP.

Cost transparency

Every response includes a costs object breaking what you paid into category buckets:

{
  "summary": "Uniswap V3 swap: 1,000 USDC → 0.42 WETH",
  "costs": {
    "llms": 0.5741,
    "dataCollection": 0.2664,
    "codeExecution": 0.0170,
    "other": 0.0025,
    "totalUsd": 0.86
  }
}

• llms - agent reasoning tokens.
• dataCollection - traces, address labels, token prices, web research.
• codeExecution - sandboxed calldata/bytecode analysis.
• other - everything else.

The buckets sum to totalUsd, the amount charged for the analysis.

Watching the live stream? SSE mode emits progress events (tool_call, tool_result, tokens, …) as the analysis runs, and the final result event carries the full costs breakdown. See Core concepts → SSE streaming.

What's free

Discovery and health surfaces cost nothing - no payment challenge, no wallet needed:

FAQ

Is there a rate limit? No fixed limit - per-request payment is the throttle, and maxDeposit is your cap.

What if the analysis fails? oculr returns partial results (HTTP 200, confidence: 'low', a summary that starts with "Partial result") rather than failing outright - you're only metered for the work that ran. See Partial results.

Where does my payment go? Settlement is USDC.e on Tempo, token contract 0x20C000000000000000000000b9537d11c60E8b50. Funding instructions in the FAQ.

Related

• Call the oculr MPP - mppx setup and your first paid request
• Core concepts - sessions, confidence levels, partial results
• FAQ - wallet funding, supported chains, troubleshooting