Skip to main content

Free Kusama Asset Hub RPC (KSM)

Explore Kusama Asset Hub, a system parachain for low-cost asset creation, transfers, and NFT management on the Kusama network.

99.9%
2
24/7
FREE
Gateway

Connect to Kusama Asset Hub

Access reliable, enterprise-grade endpoints that power your dApp with ultra-low latency and 99.9% uptime.

Connect to Kusama Asset Hub Gateway

Make your first RPC call on Kusama Asset Hub's Blockchain Gateway.

Mainnet

Mainnet
Mainnet Explorer
JSON-RPC
https://kusama-assethub.gateway.tatum.io
REST API
https://kusama-assethub.gateway.tatum.io/v1

* Rate limit enabled - perfect for testing and development. For production, we recommend to Upgrade.

Ready for production?

Get 200 requests/second, priority support and advanced blockchain features.

Global Load Balancer

Route to nearest node

Batch RPC Calls

Multiple requests at once

Archive Nodes

Historical blockchain data

Debug & Trace

Advanced debugging

Advanced Analytics

Usage & performance

Bring Your Own RPC

Custom RPC gateways

Upgrade
Get Free API Key

Increase your limit and access all network features in Tatum Development Platform.

Accessible to Everyone

No signup. No paywalls. Just RPC that works. Great ideas come from everywhere.

Our Mission

With love by Tatum

Method reference

Kusama Asset Hub methods

Every method the Kusama Asset Hub gateway accepts, grouped by interface. 110 in total, read live from the node rather than kept by hand.

Mainnet is the live Kusama Asset Hub network. Every transaction it accepts is final, and every KSM balance it reports is real money.

There is no public test network for Kusama Asset Hub on the gateway, so development happens against Mainnet itself. Reads cost nothing and change nothing, which covers most of what you need before you start signing transactions.

Kusama Asset Hub answers over 2 interfaces: JSON-RPC and REST. Each is listed once below with every method it accepts. The endpoints differ per network, and all of them are in the gateway list above.

What sits between you and Kusama Asset Hub

A node is a machine running Kusama Asset Hub with a copy of the chain. Your code cannot ask the chain directly, it asks a node. The gateway picks a healthy one for every call, so you point at one URL instead of one machine.

  • One URL, nothing to run or keep patched yourself.
  • Calls routed to a node that is up and in sync.
  • A failing node is skipped rather than returned to you as an error.

JSON-RPC

45 methods
https://kusama-assethub.gateway.tatum.io

The default. Every wallet, library and framework speaks it, and it is what you want unless you specifically need something else.

One POST carries a method name, its parameters and an id, and the response comes back on the same connection carrying that same id. Requests are independent, so there is no session to keep alive and nothing to reconnect, which is why it runs unchanged behind a load balancer or inside a serverless function. Send an array instead of a single object and the node works through the whole batch in one round trip.

Where it fits

  • Anything your library already does for you. ethers, web3.js, viem and their equivalents all target this.
  • Batching reads. One array of twenty calls costs one round trip instead of twenty.
  • Stateless and serverless deployments, because nothing has to stay connected between calls.
  • Historical queries, by passing a block number where you would otherwise pass latest.

Trade-offs

  • It cannot push. Finding out that a block landed means polling for it, or moving to WebSocket.
  • Wide log queries get refused. Page through in fixed block windows and merge the results yourself.
  • Batch responses may come back in any order. Match them on id, never on position.

Enabled and tested methods

Read live from the endpoint, so this is what it actually serves today rather than what the protocol allows in principle. Anything not on this list returns a method-not-found error.

author_pendingExtrinsics
Lists extrinsics waiting in the transaction pool.
author_removeExtrinsic
Removes an extrinsic from the transaction pool.
author_submitAndWatchExtrinsic
Submits an extrinsic and streams its status until it is finalised.
author_submitExtrinsic
Submits a signed extrinsic and returns its hash.
beefy_getFinalizedHead
Returns the latest block finalised by BEEFY.
chain_getBlock
Returns a block, including its extrinsics and justifications.
chain_getBlockHash
Returns the block hash at a given height.
chain_getFinalizedHead
Returns the hash of the latest finalised block.
chain_getHead
Returns the hash of the current best block.
chain_getHeader
Returns a block header.
childstate_getKeys
Lists the storage keys held in a child trie.
childstate_getKeysPaged
Lists child-trie storage keys a page at a time.
childstate_getStorage
Reads a storage entry from a child trie.
childstate_getStorageEntries
Reads several child-trie storage entries at once.
childstate_getStorageHash
Returns the hash of a child-trie storage entry.
childstate_getStorageSize
Returns the byte size of a child-trie storage entry.
grandpa_proveFinality
Returns a proof that a block was finalised by GRANDPA.
grandpa_roundState
Returns the current GRANDPA voting round state.
mmr_generateProof
Generates a Merkle Mountain Range proof for a set of leaves.
mmr_root
Returns the current Merkle Mountain Range root.
mmr_verifyProof
Verifies a Merkle Mountain Range proof against the node state.
mmr_verifyProofStateless
Verifies a Merkle Mountain Range proof against a supplied root.
payment_queryFeeDetails
Breaks down the fee an extrinsic would pay.
payment_queryInfo
Returns the weight and estimated fee of an extrinsic.
rpc_methods
Lists the RPC methods the node exposes.
state_call
Calls a runtime API method directly.
state_getChildReadProof
Returns a read proof for child-trie storage keys.
state_getKeys
Lists storage keys matching a prefix.
state_getKeysPaged
Lists storage keys matching a prefix, a page at a time.
state_getMetadata
Returns the runtime metadata describing pallets, calls and storage.
state_getReadProof
Returns a read proof for a set of storage keys.
state_getRuntimeVersion
Returns the runtime version, including spec and transaction versions.
state_getStorage
Reads a raw storage entry.
state_getStorageHash
Returns the hash of a storage entry.
state_getStorageSize
Returns the byte size of a storage entry.
state_queryStorageAt
Reads several storage keys at a given block.
sync_state_genSyncSpec
Returns a chain spec suitable for warp syncing a light client.
system_chain
Returns the chain name the node is running.
system_chainType
Returns the chain type, such as Live, Local or Development.
system_health
Reports peer count, sync state and whether the node should have peers.
system_name
Returns the node implementation name.
system_nodeRoles
Returns the roles the node performs, such as Full or Authority.
system_properties
Returns chain properties such as token symbol, decimals and address prefix.
system_syncState
Returns the starting, current and highest known block heights.
system_version
Returns the node implementation version.

Common JSON-RPC errors

What you are most likely to hit calling this interface, and what to do about it.

-32700
Parse error. The request body was not valid JSON. Check that the body is serialised JSON and that Content-Type is application/json.
-32600
Invalid request. The JSON parsed, but it is not a well-formed JSON-RPC call. Include jsonrpc, method and id fields. A batch must be a non-empty array.
-32601
Method not found. This node does not expose the method you called. Check the spelling and the namespace, and confirm the method is in the list above for this network. Tracing methods in particular are not enabled everywhere.
-32602
Invalid params. The method exists but the arguments are wrong. Check argument order and types. Most EVM methods want hex-encoded quantities, and a block parameter such as latest or a hex height.
-32603
Internal error. The node failed while handling an otherwise valid request. Retry with backoff. If it persists on one method, it is usually that method rather than the node.
-32000
Server error. A catch-all the node uses for execution failures, most often a reverted call or a request over a limit. Read the accompanying message. Execution reverted means your call failed on chain, not in transport. Narrow the block range if you are querying logs.
HTTP 429
Rate limited. You have exceeded the free tier request allowance. Back off and retry, batch reads into single calls, or move to a dedicated endpoint for production traffic.
HTTP 413
Payload too large. The request body exceeded what the node accepts. Split large batches into smaller ones.

REST

65 methods
https://kusama-assethub.gateway.tatum.io/v1

Every resource has its own URL, so a request is just an address you can open.

Paste it into a browser, curl it, or bookmark it. There is no body to construct and no method name to look up, and because a read is a plain GET, ordinary HTTP caching applies at the CDN and in your own client. Responses are JSON, and the path itself usually tells you what you are getting.

Where it fits

  • Getting oriented on an unfamiliar chain without writing any code first.
  • Caching, because a GET can be cached by anything sitting between you and the node.
  • Debugging, since the request that failed is a URL you can paste to a colleague.

Trade-offs

  • You get exactly what the endpoint returns. There is no way to ask for less, or for more.
  • Building a full picture takes several round trips where one batched JSON-RPC call would do.
  • Paths carry version prefixes and shift between node releases more readily than method names do.

Enabled and tested methods

Read live from the endpoint, so this is what it actually serves today rather than what the protocol allows in principle. Anything not on this list returns a method-not-found error.

GET /{accountId}/asset-balances
Returns the asset balances held by an account.
GET /accounts/{accountId}/asset-approvals
Returns approvals an account has granted over an asset.
GET /accounts/{accountId}/balance-info
Returns free, reserved, locked and transferable balance for an account.
GET /accounts/{accountId}/convert
Converts an account ID between SS58 formats and its public key.
GET /accounts/{accountId}/foreign-asset-balances
Returns the balances an account holds in foreign assets.
GET /accounts/{accountId}/pool-asset-approvals
Returns approvals an account has granted over a pool asset.
GET /accounts/{accountId}/pool-asset-balances
Returns the balances an account holds in pool assets.
GET /accounts/{accountId}/proxy-info
Returns the proxy relationships configured for an account.
GET /accounts/{accountId}/staking-info
Returns staking ledger details for an account, including bonded and unlocking funds.
GET /accounts/{accountId}/staking-payouts
Returns staking payouts owed to an account across recent eras.
GET /accounts/{accountId}/validate
Checks whether an address is valid and returns its network and format.
GET /accounts/{accountId}/vesting-info
Returns the vesting schedule locking an account balance.
GET /accounts/compare
Compares an address across formats to confirm they refer to the same account.
GET /ahm-info
Returns Asset Hub migration status information.
GET /blocks
Returns a range of blocks with their extrinsics and events.
GET /blocks/{blockNumber}
Returns a block by height, with its extrinsics and events.
GET /blocks/{blockNumber}/extrinsics-raw
Returns the raw, undecoded extrinsics of a block at a height.
GET /blocks/{blockNumber}/extrinsics/{extrinsicIndex}
Returns a single extrinsic from a block at a height.
GET /blocks/{blockNumber}/header
Returns the header of a block at a height.
GET /blocks/{blockNumber}/para-inclusions
Returns the parachain candidates included in a relay-chain block.
GET /blocks/head
Returns the newest block, with its extrinsics and events.
GET /blocks/head/header
Returns the header of the newest block.
GET /capabilities
Lists the endpoints this Sidecar instance supports for the connected chain.
GET /coretime/info
Returns current Coretime configuration and cycle information.
GET /coretime/leases
Lists active Coretime leases.
GET /coretime/overview
Returns a summary of Coretime sales, regions and reservations.
GET /coretime/regions
Lists Coretime regions and who holds them.
GET /coretime/renewals
Lists Coretime cores eligible for renewal.
GET /coretime/reservations
Lists cores reserved for system parachains.
GET /health
Reports whether Sidecar and the node behind it are reachable.
GET /node/network
Returns peer count, listening addresses and network identity of the node.
GET /node/transaction-pool
Lists the extrinsics currently in the transaction pool.
GET /node/version
Returns the client name, version and chain of the node.
GET /pallets/{palletId}/consts
Lists the constants a pallet defines.
GET /pallets/{palletId}/consts/{constantItemId}
Returns the value of one pallet constant.
GET /pallets/{palletId}/dispatchables
Lists the callable extrinsics a pallet exposes.
GET /pallets/{palletId}/dispatchables/{dispatchableItemId}
Returns the signature and docs of one callable extrinsic.
GET /pallets/{palletId}/errors
Lists the errors a pallet can return.
GET /pallets/{palletId}/errors/{errorItemId}
Returns the definition of one pallet error.
GET /pallets/{palletId}/events
Lists the events a pallet can emit.
GET /pallets/{palletId}/events/{eventItemId}
Returns the definition of one pallet event.
GET /pallets/{palletId}/storage
Lists the storage items a pallet defines.
GET /pallets/{palletId}/storage/{storageItemId}
Reads one storage item from a pallet.
GET /pallets/asset-conversion/liquidity-pools
Lists the liquidity pools registered in the asset-conversion pallet.
GET /pallets/asset-conversion/next-available-id
Returns the next free pool asset ID.
GET /pallets/assets/{assetId}/asset-info
Returns metadata and supply for an asset.
GET /pallets/foreign-assets
Lists the registered foreign assets.
GET /pallets/nomination-pools/{poolId}
Returns the state of one nomination pool.
GET /pallets/nomination-pools/info
Returns global nomination-pool configuration and limits.
GET /pallets/on-going-referenda
Lists referenda currently open for voting.
GET /pallets/pool-assets/{assetId}/asset-info
Returns metadata and supply for a pool asset.
GET /pallets/staking/progress
Returns era and session progress for staking.
GET /pallets/staking/validators
Lists the current staking validators.
GET /runtime/code
Returns the on-chain runtime WASM blob.
GET /runtime/metadata
Returns the runtime metadata describing pallets, calls and storage.
GET /runtime/metadata/v14
Returns runtime metadata in the v14 format.
GET /runtime/metadata/versions
Lists the metadata versions the runtime can emit.
GET /runtime/spec
Returns the runtime spec name, version and chain properties.
GET /transaction/material
Returns the metadata, genesis hash and nonce needed to build a transaction.
GET /transaction/material/v14
Returns transaction construction material using v14 metadata.
POST /transaction
Submits a signed transaction to the network.
POST /transaction/dry-run
Executes a transaction without submitting it, returning the outcome.
POST /transaction/fee-estimate
Returns the fee a transaction would pay.
POST /transaction/metadata-blob
Returns the metadata blob used for offline signing.
POST /transaction/parse
Decodes a signed transaction into readable calls.

Common REST errors

What you are most likely to hit calling this interface, and what to do about it.

400
Bad request. A path or query parameter is malformed. Check the parameter format, and that path values are URL-encoded.
404
Not found. Either the path is wrong, or the resource genuinely does not exist at that height. Confirm the path against the list above. A valid path can still 404 for pruned history on a non-archive node.
429
Rate limited. You have exceeded the free tier request allowance. Back off and retry. REST responses cache well, so caching on your side removes most repeat traffic.
500
Internal server error. The node failed while handling the request. Retry with backoff.
503
Service unavailable. The node is starting, resyncing, or temporarily out of rotation. Retry with backoff; this is normally short-lived.
Blockchain Data

Indexed Kusama Asset Hub Data Insights

Complete on-chain data access, no infrastructure to run yourself. Query wallets, tokens, NFTs, and transaction history with lightning-fast APIs.

Learn more

About Kusama Asset Hub

What it is, and guides for building on it.

Kusama Asset Hub provides developers with efficient tools to mint and manage fungible and non-fungible assets, enabling experimentation with token economics and cross-chain asset functionality in a live, low-risk environment.

FAQ

Frequently Asked Questions

Everything you need to know about Kusama Asset Hub RPC endpoints

Quick Answer: What is Kusama Asset Hub RPC?

RPC (Remote Procedure Call) is the standard way to interact with the network programmatically - reading on-chain data, submitting transactions, and deploying smart contracts through JSON-RPC calls. The free tier ships 5 requests per minute with no registration required, which covers most learning and testing workflows. Production applications typically move to Tatum Premium for 200 requests per second and enterprise-grade reliability.

What is Kusama Asset Hub RPC?

RPC (Remote Procedure Call) is the interface that lets developers interact with the network: read on-chain data, submit transactions, and deploy smart contracts programmatically over standard JSON-RPC methods, without running your own node.

How do I connect to Kusama Asset Hub using these RPC endpoints?

Simply copy the RPC endpoint URL from above and configure it in your Web3 library (ethers.js, web3.js), wallet (MetaMask, Trust Wallet), or development tool (Hardhat, Truffle). The endpoint works immediately with no registration required for the free tier.

What are the rate limits for the free RPC tier?

Free tier RPC endpoints are limited to 5 requests per minute. This is perfect for testing and development. For production applications, we recommend upgrading to Tatum Premium which offers 200 requests per second with no daily limits.

When should I upgrade to Premium?

Consider upgrading to Premium when you're moving to production, need higher rate limits (200 req/sec), require 99.9% uptime SLA, want access to archive nodes for historical data, or need advanced features like batch RPC calls, debug/trace methods, and priority support.

Is Kusama Asset Hub RPC free forever?

Yes! Our free tier RPC endpoints are free forever with 5 requests per minute. This tier is perfect for learning, testing, and small projects. There are no hidden fees or time limits on the free tier.

What happens if I exceed the free tier rate limit?

If you exceed 5 requests per minute on the free tier, you'll receive an HTTP 429 (Too Many Requests) error. This is a standard rate limiting response. To avoid this, you can upgrade to Tatum Premium which offers 200 requests per second with no daily limits, perfect for production applications.

Can I use these Kusama Asset Hub RPC endpoints with MetaMask?

Yes! You can configure MetaMask to use our RPC endpoints. Simply copy the endpoint URL from above, go to MetaMask Settings > Networks > Add Network (or edit existing), and paste the RPC URL. This works with all EVM-compatible networks, including this one.

Are these RPC endpoints secure?

Yes, all our RPC endpoints use HTTPS encryption and follow enterprise-grade security practices. They're powered by Tatum's infrastructure which maintains 99.9% uptime.

What's the difference between mainnet and testnet RPC endpoints?

Mainnet carries real transactions with real value, so every write is final. Testnet runs on a separate network funded with free test tokens, which makes it the safe place to try new code, retry failed calls, and simulate edge cases. Always validate on testnet before pointing production traffic at mainnet.

How do I troubleshoot RPC connection errors?

If you're experiencing connection errors, check: 1) The RPC endpoint URL is correct, 2) You're not exceeding rate limits (5 req/min for free tier), 3) Your network allows HTTPS connections, 4) The network is currently operational. For persistent issues, check our status page or contact support.

Can I use these endpoints in production?

Free tier endpoints can be used in production for low-traffic applications (under 5 req/min). For production apps with higher traffic, we strongly recommend Tatum Premium for guaranteed uptime, faster rate limits, and enterprise SLA.
Related Blockchains

Discover RPC endpoints for other popular blockchain networks