Contention-aware fees
Fee data comes from hot accounts such as AMM pools and Jito tip accounts, so the number reflects what competitive transactions truly pay.
Execution intelligence for Solana
Land every transaction when it matters.
Agents, perp traders and tokenized-asset apps lose money to dropped transactions. Axiomora reads the live fee market and Jito tip floor, prices your compute budget to the percentile you need, and hands it to your bot over a single API call.
- Slot
- Fast tier price
- Jito tip floor (p50)
- Non-vote TPS
Live telemetry
The fee market, read straight from mainnet.
Current slot
Non-vote TPS
SOL price
Jupiter price API
Epoch
Priority fee heat strip
Fee needed to write to contended accounts (top AMM pools, Jito tip account) over the last 150 slots, oldest on the left.
Loading
How it works
From raw network noise to a transaction that lands.
Four deterministic steps, every one of them verifiable against public Solana RPC data.
- 01
Observe
Axiomora samples recent prioritization fees on the most contended writable accounts, the ones real traffic fights over, instead of the near-zero global average that tells you nothing about competitive inclusion.
getRecentPrioritizationFees / contended accounts / 150 slots
- 02
Price
Fees are reduced to percentiles and combined with the Jito landed-tip floor. Each urgency tier maps to a percentile, so you choose how much certainty to buy instead of guessing a number.
p50 / p75 / p90 / p99 + Jito tip floor
- 03
Simulate
The exact transaction you intend to send is simulated on mainnet. The compute limit is sized from real units consumed with a safety margin, so you never overpay for unused compute.
simulateTransaction / units consumed / margin
- 04
Land
A compute-budget transaction is built in your browser and signed by your own wallet. Axiomora never sees your keys, and the signature is tracked until the cluster confirms it.
ComputeBudgetProgram / wallet signature / confirmation
Fee planner
Price every transaction against the live market.
Pick a workload and an urgency. Axiomora prices the compute budget from the last 150 slots, simulates it against mainnet to size the limit exactly, then signs and lands it with your wallet.
1. Workload
2. Urgency
Top decile. For swaps and order placement.
3. Transaction
A SOL transfer wrapped in your priced compute budget. Leave the recipient empty for a fee-only self-transfer.
SOL
Urgency tiers
Pay for certainty only when it is worth it.
Live values for each tier are shown in the planner above. Use this guide to choose the right one.
| Tier | Use it for | Trade-off |
|---|---|---|
| Economy | Non-urgent settlement, batch jobs, anything that can retry | Lowest cost, may wait several slots |
| Standard | Everyday transfers, swaps in calm markets, treasury moves | Balanced cost and inclusion |
| Fast | Volatile markets, perp orders, time-sensitive agent actions | Higher percentile plus Jito tip |
| Critical | Liquidations, arbitrage, large tickets where a miss is costly | Top percentile and tip, maximum certainty |
Capabilities
Infrastructure-grade, without the infrastructure.
Jito tip intelligence
Landed-tip percentiles from the Jito block engine feed the Fast and Critical tiers, pairing compute price with a sized bundle tip.
Simulation-sized compute
Compute limits come from a real mainnet simulation of your transaction, not a flat 200k default that wastes fee budget.
Non-custodial by design
Transactions are built client-side and signed by Phantom, Solflare or Backpack. No keys, no deposits, no accounts.
Agent-ready API
One CORS-enabled GET returns the exact compute-budget values a bot attaches to its transaction. No SDK or API key required.
Hardened proxy
RPC traffic runs through an allow-listed server proxy with input validation, so credentials and unsafe methods never reach the browser.
Agent-ready API
One GET request. Your bot never guesses a fee again.
The same engine behind the planner is exposed as an open JSON endpoint with CORS enabled. Autonomous agents, keepers and trading bots call it right before signing and receive the exact compute-budget instructions to attach.
- Percentiles computed from the last 150 slots of real prioritization fees.
- Jito tip recommendations sourced from the live landed-tip floor.
- Cost returned in lamports and USD so budgets can be enforced in code.
const fees = await fetch("https://YOUR_DOMAIN/api/fees?urgency=fast&cu=200000").then(r => r.json())
tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: fees.computeUnits }))
tx.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: fees.computeUnitPrice })) Try it live
GET /api/fees?urgency=fast&cu=200000// Response appears here
Use cases
Built for where Solana volume actually lives.
Every serious Solana workload shares one risk: a transaction that does not land when it should.
Agents
Autonomous agents
Agents that pay, trade and rebalance without a human cannot retry blindly or overpay.
Call the API before every signature, cap spend per action in code, and fall back to a lower tier when the market is calm.
Perps
Perp and orderbook traders
Onchain orderbooks reward the transaction that lands first, and a dropped order is a missed fill.
Run Standard in quiet markets and escalate to Fast or Critical only when fees spike, so you pay for speed only when it matters.
RWA
Tokenized assets and stablecoins
Settlement for tokenized equities and stablecoins cannot tolerate silent drops on large tickets.
Use Standard by default and price certainty by ticket size, with a simulation check before anything is signed.
Keepers
Keepers and liquidators
Liquidation races are decided inside a single slot.
Critical tier pairs a top-percentile compute price with a Jito tip sized from landed bundles.
Launches
Mints and high-demand launches
Mint windows create sudden contention that pushes normal fees below the inclusion line.
Read live contended-account fees right before the window opens and set your budget from real data.
Wallets
Wallets and consumer apps
Users blame the app when a transaction stalls, and a fixed fee is either wasteful or too low.
Show users a clear Economy, Standard or Fast choice backed by live data instead of one hardcoded fee.
FAQ
Straight answers.
Does Axiomora hold my keys or funds?
No. Transactions are built in your browser and signed by your own wallet. Axiomora has no accounts, deposits or custody of any kind.
Does a higher tier guarantee my transaction lands?
No. Tiers are statistical estimates from recent network data. They raise the odds of inclusion but cannot guarantee it, because conditions can change within a single slot.
Where does the data come from?
Solana RPC for slots, performance samples and prioritization fees, the Jito block engine for landed-tip percentiles, and Jupiter for the SOL price.
Do I need an API key to use the agent API?
No. The fee endpoint is a plain CORS-enabled GET request. For heavy production traffic, deployers should point the app at a dedicated RPC provider.
What does a planner send cost?
The default action is a self-transfer that costs only the network fee plus your chosen priority fee, a few thousand lamports. You can simulate first at no cost.
Which wallets are supported?
Phantom, Solflare and Backpack, using their injected browser providers.
Stop guessing fees. Start landing.
Price your next transaction against live mainnet data, or wire the API into your agent in a single call.