Inference output

By model, last 24 hours

Each block records the model it was mined with. Each model is counted in its own tokens.

Window: 24 hours ending 25 Oct 2026, 00:19 UTC, tip block #32,875. A bigger model makes fewer tokens for the same work, but each of its tokens costs more compute and is priced higher.

Daily history

Full UTC days, last 30 days · Qwen3.8-27B from block #31,528. Value uses today's prices for every day, so the chart shows changes in output, not in prices. Hover a bar for exact numbers.

Compute value vs. what miners are paid

Last 24 hours. Block rewards are the only income miners get today; transaction fees are close to zero.

One RTX 5090 on Qwen3-8B: 18.6 proof attempts/s × 256 ≈ 4,762 tokens/s ≈ 411.40 M tokens a day. Bought on OpenRouter that is about $62$33 a day. The same card earns about 0.20 TSC ≈ $1.12 a day.

How it's calculated

Four steps, all from public data. Nothing is entered by hand; the page updates with every site refresh.

1. One proof attempt = 256 generated tokens. A miner generates a 256-token continuation token by token (sampling is seeded by hashes, so it is real autoregressive generation, not just reading text), hashes the result and checks it against the target. A miss means a new attempt. Source: TensorCash verifiable-inference whitepaper (256-token proof window).
2. Attempts per block = base difficulty. Difficulty is the expected number of attempts needed to find a block. We take the explorer's effective difficulty and divide it by the block's proof price multiplier: the multiplier is a penalty for suspicious sampling, not extra tokens. The explorer uses the same basis for its own inference figure.
   tokens(block) = effective_difficulty ÷ price_multiplier × 256
3. Sum per model. Every block carries its model. A bigger model has a proportionally lower difficulty, because each attempt costs more compute, so its tokens are counted as its own tokens and never converted.
   tokens/s(model) = Σ tokens(blocks of that model, last 24h) ÷ 86,400
4. Price of output tokens. From the OpenRouter API, USD per 1M output tokens, because the proof is generation. "Median" is the median over all providers currently serving the model; "cheapest" is the lowest of them.
   value(model) = tokens(model) ÷ 1,000,000 × price per 1M output tokens

Worked example: the newest block of each model

Check any block yourself: the explorer API /v1/blocks returns difficulty, proof.price_multiplier and model.name for every block.

Automatic checks on every update

• Work cross-check: base work must stay between 85% and 100% of the effective work this site uses for the network work rate (now 97.0%). If not, dollar values are paused.
• Explorer basis: the explorer must still report its inference basis as qt_base_difficulty_256_tokens_600_seconds (now: qt_base_difficulty_256_tokens_600_seconds). If the protocol changes the proof window, dollar values are paused until reviewed.
• Hardware sanity check: total work is 863.1 K proof/s (Qwen3-8B-equivalent), about 46,402 RTX 5090s at 18.6 attempts/s each, i.e. ~4,762 tokens/s per card: a realistic batched decode speed for an 8B model.
• Prices: read directly from the OpenRouter API once a day, not from price aggregators. If OpenRouter is unreachable the last prices stay, with their date; after 7 days they are dropped.

Prices used

USD per 1M tokens, OpenRouter API, refreshed once a day (last: 25 Oct). Input prices are shown for reference only.

Limits: what these numbers are not

• Not revenue, not demand. Nobody orders or pays for these tokens; the outputs are discarded once a block is found. Miners are paid only by block rewards.
• Upper bound. The count assumes every attempt is a full, fresh 256-token generation. Miners that reuse already computed parts of the text between attempts generate fewer real tokens for the same work; the whitepaper discusses this kind of cached search.
• Prices move. OpenRouter prices change often and differ 2–3× between providers for the same model, which is why both median and cheapest are shown.
• Proxy prices are used for a model no provider serves (see Prices used).
• Prompt tokens are not counted. Only the 256 generated tokens per attempt. Reading the prompt also costs compute, so the true figure is slightly higher on that side.
• Why not the explorer's own "tokens per second"? It takes the current Qwen3-8B base difficulty and assumes a block every 600 seconds, so it counts all work as Qwen3-8B tokens, including work done on bigger models, and does not follow the actual block times. We count each block in its own model instead.

Sources

• TensorCash verifiable-inference whitepaper
  What one proof attempt is: a 256-token autoregressive generation with hash-seeded sampling, checked against the target.
• Explorer API api.tscscan.xyz/v1/blocks
  Per block: height, time, difficulty (effective), proof.price_multiplier, model.name. Basis of every token count.
• Explorer API api.tscscan.xyz/v1/network/overview
  Field inference.basis confirms the base-difficulty × 256 method; checked on every update.
• OpenRouter API openrouter.ai/api/v1/models/<id>/endpoints
  Live providers of each mined model with input and output prices.
• OpenRouter API openrouter.ai/api/v1/models
  Prices of the proxy models.
• SafeTrade TSC/USDT ticker
  TSC price for the block reward comparison.
• tsc.watch calculator
  RTX 5090 speed (18.6 proof attempts/s on Qwen3-8B) used in the hardware check.

FAQ