How to get an Elysium RPC endpoint (2026 guide)

TL;DR

The first call that breaks on an Elysium RPC endpoint is usually one that works on every other EVM chain: a plain HYPE transfer with a hard-coded 21,000 gas limit is rejected with intrinsic gas too low, a pending-transaction listener never fires, and the elysiumTestnet chain bundled with viem points at a different network entirely (chain ID 1338, paid in LAVA, built by Vulcan Forged). Each one has a chain-specific cause: Nitro adds the cost of posting a transaction to the parent chain on top of intrinsic gas, a single sequencer means there is no public mempool, and “Elysium” is a name two unrelated projects share. Add that Elysium is testnet-only today (chain ID 99801, mainnet unannounced) and that the free public endpoint caps eth_getLogs at 2,000 blocks and gates debug_* behind an API key. This guide explains how Elysium RPC works, where the public endpoint stops being enough, and how to deploy a private Elysium Testnet endpoint on Chainstack in 2026.

What is an Elysium RPC endpoint

An Elysium RPC endpoint is the connection your code uses to read and write on Elysium, an Arbitrum Orbit Layer 2 built by Kinetiq that settles to HyperEVM and uses HYPE as its native gas token. Elysium runs Arbitrum Nitro, so the API is standard Ethereum JSON-RPC over HTTPS and WebSocket: eth_*, net_*, web3_*, and debug_* for tracing. Solidity and Vyper contracts compile unchanged. The Elysium-specific extras, a HyperCore market-data precompile and an ElysiumCoreWriter predeploy, are planned for an upgrade about four weeks after mainnet, so today an Elysium endpoint behaves like an Orbit chain endpoint with very short blocks.

On Elysium Testnet, the endpoint is what your application leans on for:

• Reading HYPE balances and contract state (eth_getBalance, eth_call)
• Estimating gas before sending, because even a plain transfer costs slightly more than 21,000 (eth_estimateGas)
• Broadcasting signed transactions and confirming them from receipts (eth_sendRawTransaction, eth_getTransactionReceipt)
• Streaming new blocks and logs over WebSocket (eth_subscribe with newHeads and logs)
• Tracing a failed transaction (debug_traceTransaction)
• Backfilling event history (eth_getLogs)

You can review the chain parameters and architecture in the Elysium chain specifications.

On a chain that produces roughly four blocks a second and has no mempool, the endpoint is the only place your code can learn that a transaction landed, so endpoint quality is the quality of your confirmation logic.

How Elysium RPC differs from Ethereum RPC

Elysium accepts the same JSON-RPC calls as Ethereum, but several behaviors that Ethereum tooling takes for granted are different enough to break a straight port.

Property	Ethereum	Elysium Testnet
Block time	About 12 s	About 0.25 to 0.32 s observed on October 2, 2026; 100 to 200 ms design target
Settlement	Itself	HyperEVM Testnet (chain ID 998)
Gas token	ETH	HYPE, 18 decimals, bridged 1:1 from HyperEVM
Chain ID	1	99801 (mainnet not published)
Mempool	Public	None: a single sequencer, and pending subscriptions deliver nothing
Gas for a plain transfer	21,000	About 21,140, because the parent-chain posting cost is included
Tracing	debug_* and trace_*, depending on the client	debug_* only; trace_* and arbtrace_* return -32601

Two consequences matter for provider selection. Every limit defined in blocks covers very little time: a 10,000-block eth_getLogs request spans about 40 minutes of chain time, and eth_getProof serves only blocks less than 127 behind the tip, roughly 30 seconds. And because nothing is delivered from a mempool, the endpoint must serve block and receipt reads fast enough to be your only signal.

Elysium RPC endpoint options

Public vs private Elysium RPC endpoints

A public endpoint is enough to check that chain 99801 answers; it stops being enough when you need traces, wide log scans, or sustained block streaming.

Official public endpoints:

• Mainnet: not published yet, listed as “Coming soon” by Kinetiq
• Testnet: https://testnet-rpc.elysium.kinetiq.xyz (chain ID 99801)

⚠️ In a check on October 5, 2026, the public testnet endpoint rejected eth_getLogs ranges above 2,000 blocks, answered debug_* calls with -32401 unless an API key was supplied, and began returning HTTP 429 when 60 requests arrived in parallel. The network details in Kinetiq’s Building on Elysium docs list only an HTTPS URL for it.

Feature	Public endpoint	Private endpoint (Chainstack)
Access	Free and open	Restricted access
Resources	Shared infrastructure	Your plan’s quota on Global Nodes, or isolated Dedicated Nodes
Best use case	Development & testing	Load testing and pre-mainnet readiness
eth_getLogs range	2,000 blocks (observed October 5, 2026)	Up to 10,000 blocks on Growth and above; 100 on Developer
debug_* tracing	API key required	Included on paid plans
WebSocket	None documented	HTTPS and WSS on Global Nodes

With blocks arriving every quarter of a second, a log backfill or a trace session that fits on a public endpoint on Ethereum overruns its limits within minutes on Elysium, which is why anything beyond a smoke test belongs on a private endpoint.

Full node vs archive Elysium node

At roughly four blocks a second, “recent” on Elysium means the last half minute: Chainstack classifies a request as archive once it targets a block 127 or more behind the tip.

Full node access	Archive node access
Latest balances and nonces before you send	Balances, code, or storage at a block more than 30 seconds old
eth_call and eth_estimateGas against the current state	Re-running a past eth_call against historical state
Recent logs and new-block streams	eth_getLogs backfills that start more than 30 seconds back
Tracing a transaction from the last few seconds	Tracing an older transaction with debug_traceTransaction

Chainstack serves Elysium Testnet in Archive mode on Global Nodes, and offers Full or Archive on Dedicated Nodes; see Chainstack’s archive node overview for how archive data works. An indexer that backfills a contract’s logs from its deployment block is on archive territory from its first call, so confirm archive access before you design the backfill.

HTTPS vs WebSockets

Over HTTPS you poll for a block; over WebSocket every block is a billable push, and Elysium produces a lot of them.

Feature	HTTPS	WebSocket
Model	Request/response	Persistent connection
Complexity	Simple operationally	Requires reconnect and heartbeat logic
Best for	Receipt checks, eth_call reads, gas estimation, log backfills in pages	Live newHeads and logs streams for dashboards and indexers
Latency	Standard	Lower for frequent updates
Connection overhead	Per request	One-time handshake

On Chainstack, newHeads and logs subscriptions deliver on Elysium, newPendingTransactions subscribes but delivers nothing, and syncing returns -32601. Kinetiq’s docs list only an HTTPS URL for the public endpoint, so plan on a private endpoint if you need WebSocket.

How to get a private Elysium RPC endpoint with Chainstack

You can deploy a private Elysium RPC node on Chainstack in a few minutes:

1. Log in to the Chainstack console (or create an account).
2. Create a new project
3. Select Elysium as your blockchain protocol
4. Choose network: Elysium Testnet, the only network available until Kinetiq publishes mainnet details
5. Deploy the node
6. Open Access and credentials and copy your HTTPS and WebSocket endpoints

Pick a Global Node for shared, geo-balanced access, or a Dedicated Node in Full or Archive mode when you need isolated resources; the console marks Dedicated Nodes as requiring the Pro plan. Need testnet HYPE? Use the Kinetiq Elysium faucet or bridge testnet HYPE from HyperEVM.

Elysium is not in viem’s chain list, so define chain 99801 yourself:

import { createPublicClient, http, defineChain, formatEther } from "viem";

// Define chain 99801 yourself: "elysiumTestnet" in viem/chains is Vulcan Forged (ID 1338)
const elysiumTestnet = defineChain({
  id: 99801,
  name: "Elysium Testnet",
  testnet: true,
  nativeCurrency: { decimals: 18, name: "HYPE", symbol: "HYPE" },
  rpcUrls: { default: { http: ["YOUR_CHAINSTACK_ENDPOINT"] } },
});

const client = createPublicClient({ chain: elysiumTestnet, transport: http() });

console.log("Chain ID:", await client.getChainId());
console.log("Block:", await client.getBlockNumber());

const balance = await client.getBalance({ address: "YOUR_WALLET_ADDRESS" });
console.log("Balance:", formatEther(balance), "HYPE");

📖 For the full integration guide, including MetaMask, ethers.js, web3.py, Foundry, and Hardhat, see the Chainstack Elysium tooling documentation.

You can also access Chainstack Elysium RPC directly from Claude, Cursor, Codex, Windsurf, Gemini CLI, GitHub Copilot, Antigravity, Claude.ai, or ChatGPT using Chainstack MCP. For the full agent stack — MCP, the Chainstack skill, llms.txt, and WebMCP — see the Chainstack Agents page.

Chainlist does not list Kinetiq’s Elysium (chain ID 99801) as of October 5, 2026, and the two “Elysium” entries in the registry behind it (1338 and 1339) belong to Vulcan Forged, so add the network manually instead of picking it from a list.

Chainstack pricing for Elysium RPC

Elysium Testnet is billed like every other Chainstack EVM protocol: one request unit (RU) per full request and two per archive request, with no per-method multipliers beyond debug and trace. See the full Chainstack pricing page for plan details and overage rates.

Plan	Cost	Requests/Month	RPS	Overage (per 1M extra)
Developer	$0	3M RU	25	$20
Growth	$49 ($40 billed annually)	20M RU	250	$15
Pro	$199 ($166 billed annually)	80M RU	400	$12.50
Business	$499 ($416 billed annually)	200M RU	600	$10
Enterprise	From $990	400M RU	Unlimited	$5

Options relevant to Elysium:

• Archive and debug and trace access start at the Growth plan. Requests for blocks 127 or more behind the tip bill at 2 RU, and every debug_* call bills at 2 RU regardless of block age. See Chainstack archive data.
• The Unlimited Node add-on (Growth plan and above) replaces per-request billing with a flat monthly fee tied to an RPS tier, from $149/month for 25 RPS.
• Dedicated Nodes (Pro plan and above) for Elysium Testnet cost about $475/month in Full mode and about $548/month in Archive mode, from $0.50/hour compute plus storage.

How to estimate monthly cost

1. List the reads you make per user action: balance, gas estimate, receipt polling
2. Multiply by expected actions per month to get a request-unit baseline
3. Add log backfills and trace sessions, which bill at 2 RU when they reach back more than 127 blocks or use debug_*
4. Add headroom for retries and for new deployments, which poll receipts heavily
5. Count WebSocket notifications separately: each push counts as a request, and at the observed 3 to 4 blocks per second a single newHeads subscription generates roughly 270,000 to 345,000 notifications a day, or about 8 to 10 million RU a month, 40 to 50% of the Growth plan’s 20M RU allowance

Production readiness checklist

• Primary + fallback RPC provider configured
• Request timeout policy set
• Retry logic with exponential backoff implemented
• Credentials stored in env/secret manager (never hardcoded)
• Monitoring for latency, error rate, and throttling
• Alerts for sustained degradation
• Chain ID 99801 asserted at startup, so a Vulcan Forged config can never be used by mistake
• Gas limits estimated with eth_estimateGas, never hard-coded to 21,000
• Transaction confirmation built on receipts and new blocks, not on pending-transaction subscriptions
• eth_getLogs backfills paginated to your plan’s block cap (100 on Developer, 10,000 on Growth and above)
• Mainnet chain ID and RPC URL kept in configuration, since neither is published yet

Troubleshooting common Elysium RPC issues

Issue	Cause	Fix
intrinsic gas too low on a plain transfer	Nitro adds the parent-chain posting cost, so a transfer uses about 21,140 gas	Do not hard-code 21,000; let the library call eth_estimateGas
pending listener or newPendingTransactions subscription never fires	One sequencer and no public mempool	Watch new blocks or poll eth_getTransactionReceipt
Wrong currency symbol (LAVA) or explorer links in viem	elysiumTestnet in viem/chains is Vulcan Forged’s chain 1338	Define chain 99801 with defineChain and your own RPC URL
eth_getLogs error: block range exceeds maximum of 2000	Public endpoint cap; Chainstack caps at 100 blocks on Developer and 10,000 on Growth and above	Paginate the backfill, or move to a paid plan or a Dedicated Node with a raised cap
-32401 on debug_*, or -32601 on trace_* and arbtrace_*	The public endpoint needs an API key for debug_*; Elysium does not serve trace_* or arbtrace_*	Use debug_traceTransaction and the other debug_* tracers on a paid Chainstack node
429 Too Many Requests or dropped WebSocket	Shared public endpoint under burst, or an idle connection closed	Move to a private endpoint, add reconnect with a block-range backfill

Conclusion

The bugs that cost the most time on Elysium are the ones that look like your own code’s fault: a hard-coded gas limit that fails as intrinsic gas too low, a pending-transaction listener that never fires, a viem import that quietly points at Vulcan Forged’s LAVA chain. None of them is in a standard Ethereum checklist, and the public testnet endpoint adds a second layer of surprises with its 2,000-block log cap, API-key-gated debug_*, and 429s under burst.

The pattern that works is short. Define chain 99801 explicitly, let the library estimate gas, confirm transactions from receipts and new blocks, and put the work on a private endpoint with archive depth and debug_* from day one. Start on a Growth plan Global Node; move to the Unlimited Node add-on when subscriptions dominate your usage, or to a Dedicated Node when you need custom block-range limits. Keep the mainnet chain ID and RPC URL in configuration, because Kinetiq has not published either.

Spin up a free Elysium Testnet endpoint now, then scale as the chain approaches mainnet.

FAQ

What is Elysium’s chain ID, and is there a mainnet RPC? Elysium Testnet uses chain ID 99801 and has been live since September 22, 2026. Kinetiq lists the mainnet chain ID and RPC as “Coming soon”, so there is no Elysium Mainnet endpoint yet; Chainstack serves testnet only until that changes.

Is this the same Elysium that appears on Chainlist or in viem? No. The Elysium chains on Chainlist and in viem/chains (chain IDs 1338 and 1339, paid in LAVA) belong to Vulcan Forged. Kinetiq’s Elysium is a separate Arbitrum Orbit chain with chain ID 99801 and HYPE as gas, so define it yourself or add it to your wallet manually.

Why can’t I see pending transactions on Elysium? Elysium has a single sequencer and no public mempool. eth_newPendingTransactionFilter and eth_subscribe("newPendingTransactions") accept the request and then deliver nothing, even for transactions you send yourself, so confirm transactions from receipts and new blocks instead.

Do I need an archive node for Elysium? Almost certainly, for anything that looks back further than half a minute. At roughly four blocks per second, a request 127 or more blocks behind the tip is classified as archive, which is only about 30 seconds of chain time, so indexers and analytics jobs end up in archive territory quickly.

How do I get testnet HYPE? Use the Kinetiq Elysium faucet, or bridge testnet HYPE from HyperEVM Testnet to Elysium 1:1 through Kinetiq’s testnet bridge. Both are linked from Kinetiq’s docs and the Chainstack tooling page.

Which libraries work with an Elysium endpoint? Because Elysium runs Arbitrum Nitro, ethers.js, viem, web3.py, Foundry, and Hardhat all work unchanged. Two details to remember: define chain 99801 manually in viem, and wrap addresses in Web3.to_checksum_address() in web3.py, which rejects lowercase addresses.

Additional resources

• Elysium methods — per-method availability on Chainstack Global Nodes
• Elysium tooling — MetaMask, ethers.js, viem, web3.py, Foundry, and Hardhat setup
• Debug and trace APIs — what debug_* includes on Elysium and which tracers are disabled
• Request units — how full, archive, and WebSocket requests are billed
• Chainstack introduces Elysium Testnet support — the launch announcement
• What is Elysium? — a deep dive on the chain’s architecture and trade-offs
• Elysium on Chainstack — protocol facts at a glance