RPC & WebSocket

Push, preflight, price — 400ms blocks

HTTP

rpc.inazuma.network

WebSocket

wss · 64 subs/conn

Anon limit

25/s · burst 100

Subscribe instead of polling

One socket carries subscriptions and ordinary JSON-RPC. Subscribing returns an id; every matching event arrives as an inaz_subscription notification carrying that id. A connection may hold 64 subscriptions, and a client that stops reading is dropped rather than allowed to queue — block production is never blocked by a slow consumer.

const ws = new WebSocket("wss://rpc.inazuma.network/ws");
ws.onopen = () => ws.send(JSON.stringify({
  jsonrpc: "2.0", id: 1, method: "inaz_subscribe",
  params: { channel: "account", address: "<ADDRESS>" },
}));
ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  if (msg.method === "inaz_subscription") console.log(msg.params.result);
};

// stop listening
ws.send(JSON.stringify({ jsonrpc: "2.0", id: 2,
  method: "inaz_unsubscribe", params: { subscription: 1 } }));

heads

filter —

Every sealed block: height, hash, parent, state root, producer, tx count and the current base fee.

finality

filter —

Fires once each time the finalized height advances. Use this, not block count, to decide a payment is settled.

mempool

filter —

Every transaction this node admits, before inclusion. Hash, sender, kind, fee and pool depth.

signature

filter hash

One transaction's life: pending, then confirmed with its height, then finalized. Cancels itself once final.

account

filter address

Any block touching an address, with the post-block balance, stake and nonce. No polling for wallet balances.

logs

filter contract (optional)

Contract deploys and calls with their receipt. Omit the filter for every contract on the chain.

Check before you send

A failed transaction is a wasted block slot and a confused user. Preflight answers exactly what would happen — including the nonce the chain expects and the minimum fee it will accept — so the only transactions you broadcast are ones that land.

curl -s https://rpc.inazuma.network -H 'content-type: application/json' -d '{
  "jsonrpc":"2.0","id":1,"method":"inaz_simulateTransaction",
  "params":{"tx":{ ...signed transaction... }}
}'

# → { ok, signatureValid, expectedNonce, feeFloor,
#     totalDebit, balanceAfter, errors, warnings }

Methods worth knowing

inaz_simulateTransaction

cost 3

Preflight. Runs every admission and execution check against live state and returns the verdict — signature validity, expected nonce, fee floor, total debit, resulting balance and any errors — without writing anything or spending a single rai.

inaz_priorityFee

cost 1

Fee guidance from the live pool: floor, and the 50th/90th percentile of what is queued right now, as slow / normal / fast / urgent. Removes the guesswork from setting a fee.

inaz_signatureStatuses

cost 2

Up to 256 transaction hashes in one round trip, each answered pending, confirmed, finalized or unknown with its confirmation count.

inaz_nodeStatus

cost 1

What this endpoint is and how healthy it is: validator or replica, height, finalized height, peers, pool depth, live subscriptions and whether it is behind the tip. Point your load balancer at it.

inaz_sendTransactions

cost up to 100

Batch submit. Signatures are verified in parallel and the pool lock is taken once for the whole batch, so a thousand transactions cost one round trip instead of a thousand.

inaz_getProof / inaz_verifyProof

cost 5

Merkle proof of an account against a block's state root, so a light client or bridge can verify a balance without trusting the node that served it.

Limits, and how to raise them

Anonymous 25 requests/sec per IP with a burst of 100, 32 connections per host.
API key 300 requests/sec on its own budget, so a public flood cannot starve real traffic.
Stake-weighted bind a key to a staked account and its budget scales with its share of total stake, up to 8x.
Weighted cost methods are charged by what they cost the node — a proof counts 5, a large batch up to 100.
Per account transaction admission is throttled per signing account and capped at 64 pending, so one account cannot fill the pool from a thousand addresses.
Pool pressure when the pool is full the cheapest queued transaction is evicted for one paying more; raising your fee always buys priority.

curl -s https://rpc.inazuma.network -H 'Authorization: Bearer <KEY>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"inaz_rpcLimits","params":{}}'

Run a node →Domain & RPC security →Source on GitHub