Inazuma docs · Devnet

RPC & WebSocket

One HTTP endpoint and one socket is the whole interface to Inazuma. Plain JSON-RPC, no SDK required — start with a curl, finish with live subscriptions.

HTTP

rpc.inazuma.network

WebSocket

64 subs / conn

Anon limit

25/s · burst 100

Block time

400ms

Step 1

Connect

Check you are talking to the real chain before anything else.

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

# → { chainId: 7777, height, finalizedHeight, peers, poolDepth }

Every method takes a named params object and returns standard JSON-RPC 2.0. Errors carry a code and a human-readable message — read it, it usually names the fix.

Step 2

Subscribe instead of polling

Subscribing returns an id; matching events arrive as inaz_subscription notifications carrying that id.

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 } }));

Channel	Filter	What it pushes
heads	—	Every sealed block: height, hash, parent, state root, producer, tx count, base fee.
finality	—	Fires when the finalized height advances. Use this to call a payment settled.
mempool	—	Every transaction this node admits, before inclusion.
signature	hash	One transaction's life: pending → confirmed → finalized, then self-cancels.
account	address	Any block touching an address, with post-block balance, stake and nonce.
logs	contract (optional)	Contract deploys and calls with receipts. Omit the filter for all contracts.

A connection may hold 64 subscriptions. A client that stops reading is dropped rather than queued — block production is never blocked by a slow consumer.

Step 3

Preflight, then send

A failed transaction is a wasted slot and a confused user. Simulate first and only broadcast what lands.

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 }

Then submit with inaz_sendTransaction (or the batch form) and watch the signature channel until it reports finalized.

Method reference

Cost is the rate-limit weight each call consumes.

Method	Cost	What it does
inaz_simulateTransaction	3	Preflight against live state: signature validity, expected nonce, fee floor, total debit, resulting balance, errors. Writes nothing.
inaz_priorityFee	1	Fee guidance from the live pool as slow / normal / fast / urgent.
inaz_signatureStatuses	2	Up to 256 hashes per round trip, each pending / confirmed / finalized / unknown.
inaz_nodeStatus	1	Endpoint health: validator or replica, height, finalized height, peers, pool depth. Point your load balancer here.
inaz_sendTransactions	up to 100	Batch submit — signatures verified in parallel, pool lock taken once.
inaz_getProof / inaz_verifyProof	5	Merkle proof of an account against a block state root for light clients and bridges.

Limits and keys

Tier	Budget	How to get it
Anonymous	25 req/s per IP, burst 100, 32 connections per host	No signup
API key	300 req/s on its own budget	Public floods cannot starve real traffic
Stake-weighted	Scales with the bound account's stake share, up to 8x	Bind a key to a staked account
Per account	Throttled admission, 64 pending max	One account cannot fill the pool

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

When the pool is full, the cheapest queued transaction is evicted for one paying more — raising your fee always buys priority.

Next steps

Run a validator →Security →Source on GitHub