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 public endpoints cap eth_getLogs ranges and gate 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 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, 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
Block time	About 12 s	100 to 200 ms
Settlement	Itself	HyperEVM (chain ID 999; testnet 998)
Gas token	ETH	HYPE, 18 decimals, bridged 1:1 from HyperEVM
Chain ID	1	99801 (testnet)
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 the Elysium chain answers; it stops being enough when you need traces, wide log scans, or sustained block streaming.

Official public endpoints:

• Testnet: https://testnet-rpc.elysium.kinetiq.xyz (chain ID 99801)

⚠️ Public endpoints are shared, so expect caps on eth_getLogs ranges, API-key gating on debug_* calls, and HTTP 429 responses under parallel bursts.

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	Production traffic and load testing
eth_getLogs range	Capped; the limit varies by endpoint	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 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 Mainnet, or Elysium Testnet for development and testing
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 HYPE? Bridge HYPE from HyperEVM to Elysium 1:1 through Kinetiq’s bridge. On testnet, use the Kinetiq Elysium faucet or bridge testnet HYPE from HyperEVM.

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

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

// The elysium chain bundled with viem is Vulcan Forged's (ID 1338), not Kinetiq's.
const RPC_URL = "YOUR_CHAINSTACK_ENDPOINT";

// Read the chain ID from the endpoint instead of hard-coding it
const res = await fetch(RPC_URL, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId", params: [] }),
});
const id = parseInt((await res.json()).result, 16);

const elysium = defineChain({
  id,
  name: "Elysium",
  nativeCurrency: { decimals: 18, name: "HYPE", symbol: "HYPE" },
  rpcUrls: { default: { http: [RPC_URL] } },
});

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

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

📖 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 may not list Kinetiq’s Elysium, 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 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 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
• The expected chain ID 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)
• Chain ID and RPC URL kept in configuration

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 the Elysium chain 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 public endpoints add a second layer of surprises with log-range caps, API-key-gated debug_*, and 429s under burst.

The pattern that works is short. Define the Elysium chain 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 chain ID and RPC URL in configuration so you can switch endpoints without a code change.

Spin up a free Elysium endpoint now, then scale as your traffic grows.

FAQ

What is Elysium’s chain ID, and is there a mainnet RPC? Elysium Mainnet launched on November 9, 2026. You can read the chain ID from your endpoint with eth_chainId. Elysium Testnet uses chain ID 99801 and has been live since September 22, 2026. To get a mainnet RPC endpoint, deploy an Elysium node on Chainstack.

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 its own chain ID 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 HYPE on Elysium? On mainnet, bridge HYPE from HyperEVM to Elysium 1:1 through Kinetiq’s bridge. On testnet, use the Kinetiq Elysium faucet, or bridge testnet HYPE from HyperEVM Testnet to Elysium 1:1 through Kinetiq’s testnet bridge. These 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 the Elysium chain 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 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