Best Elysium RPC providers in 2026

Elysium is an Arbitrum Orbit chain from Kinetiq, the liquid staking protocol on Hyperliquid, that settles to HyperEVM and uses HYPE as its gas token. Kinetiq opened the Elysium testnet on September 22, 2026, as Chainstack also reports, and mainnet has not launched yet.

That timing shapes this comparison of Elysium RPC providers. Kinetiq’s docs list the mainnet chain ID, RPC endpoints, and explorer as “coming soon”, so every endpoint covered below serves the testnet (chain ID 99801). The chain targets 100 to 200 ms blocks, orders transactions through a single sequencer, and has no public mempool, which changes what a provider needs to offer: block-based limits cover far less wall-clock time than on Ethereum, and pending-transaction streams deliver nothing.

This guide compares the three options with a confirmed Elysium page or docs entry as of October 9, 2026: Chainstack, Kinetiq’s own public testnet endpoint, and Alchemy. Providers we could not confirm are left out rather than padded in.

Already using Chainstack? Jump straight to the Elysium tooling docs or deploy your endpoint in minutes.

⚠️ Not the other Elysium: an older, unrelated chain called Elysium from Vulcan Forged uses chain IDs 1338 and 1339. The elysiumTestnet export in viem points at its testnet (chain ID 1338, LAVA as its currency), not at Kinetiq’s. Define chain 99801 yourself, as the Chainstack docs show.

Why RPC provider choice matters for Elysium

A pre-mainnet chain gives you little to lean on. There is no mainnet endpoint to migrate to yet, only a testnet whose parameters Kinetiq says may be refined before launch. The provider you pick now decides how much history you can query, whether you can trace failing transactions, and how much a heavy eth_getLogs backfill costs while you build. Kinetiq also builds Elysium for high-frequency trading and market-making AMMs, which its docs call the chain’s flagship tenants, so request ceilings and tail latency matter more here than on a typical EVM chain.

Elysium also behaves differently from the EVM chains most tooling was written for. Kinetiq targets 100–200 ms blocks, and the testnet averaged about 121 ms per block over its last 100,000 blocks when we measured on October 9, 2026. A 10,000-block log query therefore covers about 20 minutes of chain time, against about 48 minutes on Arbitrum One and about 2.7 hours on HyperEVM measured the same way, and the Elysium tooling docs tell developers to paginate backfills accordingly. The criteria below separate endpoints that cope with that from endpoints that only answer eth_blockNumber.

Block times measured on October 9, 2026 over each chain’s last 100,000 blocks through public RPC endpoints.

• Cost predictability and pricing model. Chainstack bills 1 request unit per call, with archive and debug or trace requests at 2, while Alchemy compute units are method-weighted. For a workload built on eth_getLogs and traces, the sticker price is not the actual price. The Chainstack vs Quicknode vs Alchemy cost comparison has worked examples.
• Latency and request ceilings. Requests per second and tail latency decide whether a quote loop or a trading bot keeps up with 100–200 ms blocks, and newHeads over WebSocket is how you follow the chain.
• Archive and trace access. Whether debug_traceTransaction and historical state reads work, from which plan, and at what cost.
• Elysium-specific behavior. No public mempool, a short eth_getProof window, HyperCore integrations not available yet, and a mainnet that does not exist yet.
• Dedicated nodes, free tier and support. Whether isolated infrastructure is available, what the free plan excludes, and what response commitments each tier carries.

Elysium RPC providers compared

The table below summarizes public positioning as of October 2026.

Provider	Pricing model	Free tier	Dedicated nodes	Archive & trace	Elysium networks
Chainstack	Flat request units (1 RU, 2 RU archive and debug)	Yes (Developer plan)	Not confirmed for Elysium	Archive mode with debug on paid plans	Testnet
Kinetiq public RPC	Free, shared	Yes	Not offered in docs	debug_* requires an API key	Testnet
Alchemy	Method-weighted compute units	Yes (free plan)	Not documented for Elysium	Debug and Trace API listed as request-support	Testnet

Note: Quicknode does not currently list Elysium in its documentation index or docs sitemap, so it is not covered here. Teams on a Quicknode-only stack will need a separate endpoint for this network.

How to choose an Elysium RPC provider

1. Pricing model: flat vs weighted, and what that means at scale

Chainstack’s request units charge 1 RU for a full request and 2 RU for archive requests, and on Global Nodes every debug_*, trace_*, and arbtrace_* call is billed at 2 RU regardless of block age. Alchemy assigns each method a fixed compute-unit weight, and its Pay As You Go plan prices those units at $0.525 per million.

True cost per call = (method’s unit weight × price per million units) ÷ 1,000,000. Multiply by monthly call volume for the real bill. For eth_getLogs, the one-method comparison looks like this:

Provider	Unit weight for eth_getLogs	Cost per 1M calls
Chainstack (Growth plan)	1 RU near the tip, 2 RU if fromBlock is 127 or more blocks behind	$15 near the tip and $30 beyond it at the overage rate; about $2.45 to $4.90 inside the included 20M RU
Alchemy (Pay As You Go)	60 CU in Alchemy’s general EVM table	$31.50
Kinetiq public RPC	Not metered	Free, rate-limited

The Alchemy weight comes from its general compute-unit table; the Elysium chain page does not publish a separate weight, so confirm it before budgeting. Chainstack figures are from the pricing page. To model your own method mix, use the interactive cost calculator.

2. Archive, trace, and debug method access

Chainstack lists Elysium Testnet on its Global Network in archive mode with debug and trace available, and the debug and trace docs state that Elysium needs a paid plan and exposes the debug_* namespace. Tracing works back to genesis through debug_traceTransaction, debug_traceBlockByNumber, debug_traceBlockByHash, and debug_traceCall, with callTracer, prestateTracer, flatCallTracer, muxTracer, and stylusTracer among the accepted tracers. The Parity-style trace_* and arbtrace_* namespaces are not exposed; use flatCallTracer for flat traces.

On the Kinetiq public endpoint, a debug_traceTransaction call on October 9, 2026 returned -32401 authenticated API key required for method. Alchemy’s Elysium page lists the Debug and Trace APIs as request-support items rather than self-serve features. Archive access is available from Chainstack’s Growth plan; the free Developer plan does not include it.

3. Latency, throughput and Elysium-specific behavior

A 100–200 ms block target means a quote-refresh loop sends many more calls per second than on a 12-second chain, so the request ceiling is the first limit a trading workload hits. Per Chainstack’s pricing page, the Developer plan allows 25 RPS, Growth 250, Pro 400 and Business 600, and Alchemy’s pay-as-you-go plan lists 300 RPS. Averages say little here: p95 and p99 latency on eth_call, eth_getLogs and transaction submission is what a bot feels.

Three chain behaviors shape the integration. First, there is no public mempool: eth_subscribe accepts newPendingTransactions and returns a subscription ID but delivers nothing, so follow the chain with newHeads or logs instead. Second, eth_getProof serves proofs only for blocks less than 127 behind the tip, about 15 seconds at the testnet’s current block rate. Third, eth_getLogs ranges are capped at 100 blocks on Chainstack’s Developer plan (about 12 seconds of chain time) and 10,000 on Growth and above (about 20 minutes), per the limits docs.

⚡ Benchmark before you commit: compare.chainstack.com does not list Elysium yet. Run a quick latency test against each provider’s endpoint from your target region before committing — a curl loop or k6 script hitting eth_blockNumber and one heavier method (eth_getLogs, eth_call at a past block) is enough to surface meaningful p95/p99 differences.

4. Free tier, dedicated nodes and support

Chainstack’s Developer plan is free ($0 per month) with 3M request units per month and 25 RPS, and the Chainstack tutorial for Elysium states that no credit card is required; it excludes archive data and debug and trace APIs. The Kinetiq public RPC is free and shared, with no account, no documented rate limits and no support commitment beyond pointing builders to the Kinetiq team. Alchemy’s pricing page lists 30M compute units per month on its free plan, without saying whether the allowance is permanent.

Dedicated Nodes start at the Chainstack Pro plan, but Chainstack’s public pages are not consistent on whether they can be deployed for Elysium Testnet today, so confirm availability with the Chainstack team before planning around them. Until then, the Unlimited Node add-on offers flat-fee throughput tiers on any Chainstack RPC node from the Growth plan up. On support, Chainstack’s Developer plan is community-only, paid plans get Standard support with a response target under 24 hours (24×5), and Alchemy lists Bronze, Silver and Gold premium tiers at 12, 4 and 2 hours.

Choose by use case

Trading bots and market-making AMMs

Kinetiq calls high-frequency trading and market-making AMMs the flagship tenants of Elysium and sets 100–200 ms blocks so quotes can be refreshed several times per second. That workload is sensitive to what an RPC provider controls: how fast transactions land through eth_sendRawTransaction, how steadily newHeads arrives over WebSocket, and whether a request ceiling throttles a quote loop. With no public mempool, confirmation logic has to key off block inclusion, as Chainstack’s what is Elysium guide notes. The HyperCore integrations that make Elysium distinctive for trading, such as contracts that read order books or place orders, are not available on the testnet yet.

Chainstack’s Growth and Pro plans allow 250 and 400 RPS, and the Unlimited Node add-on swaps per-request billing for a flat fee tied to an RPS tier, which suits a quote loop whose call count is hard to predict. Alchemy lists 300 RPS on pay-as-you-go. The Kinetiq public endpoint documents no rate limits or SLA, so it is a place to prototype a strategy, not to run one.

DeFi development, tracing and analytics

The first thing teams do is deploy contracts, bridge testnet HYPE from HyperEVM, and exercise swaps and routers, which leans on eth_estimateGas, eth_call and receipts. One quirk bites early: Nitro adds the cost of posting to the parent chain, so a plain HYPE transfer uses about 21,140 gas and a hard-coded limit of 21,000 fails with intrinsic gas too low, as the Elysium tooling docs explain. When a router call reverts, tracing shows why: HYPE moved by a contract emits no event, so a published Chainstack tutorial walks through one Elysium transaction with 87 calls in its trace.

Teams building indexers or analytics need archive reads and a tracer-capable endpoint, which in this comparison points to Chainstack’s paid plans. Alchemy lists Debug and Trace as request-support items on its Elysium page, and Kinetiq’s public endpoint gates debug_* behind a key, so neither is a drop-in for trace-heavy pipelines today.

Elysium RPC provider breakdown

Chainstack

Chainstack serves Elysium Testnet (chain ID 99801) on Nitro, the Arbitrum client, through Global Nodes with HTTPS and WebSocket endpoints, archive mode, and debug and trace on paid plans. Chainstack’s Elysium RPC page says Mainnet will follow once Kinetiq confirms a chain ID and launch date.

Pricing is flat: 1 request unit per full request, 2 for archive and for debug or trace calls. The free Developer plan includes 3M RU and 25 RPS with no card, and the Growth plan at $49 per month adds archive, debug and trace, 20M RU, and 250 RPS, according to the pricing page. The Unlimited Node add-on replaces per-request billing with a flat monthly fee from the Growth plan. Chainstack holds SOC 2 Type II and ISO 27001 certifications.

On the technical side, the Elysium methods reference documents per-method availability: eth_subscribe for newHeads and logs, tracing back to genesis, and extended tracers including stylusTracer. Chainstack also publishes an Elysium tutorial for tracing internal calls and HYPE transfers.

Limitations: Elysium is testnet-only on Chainstack today. Debug, trace, and archive requests need a paid plan, and eth_getLogs is capped at 100 blocks on the free plan. The trace_*, arbtrace_*, and txpool_* namespaces are not served on Global Nodes, and eth_getProof works only for recent blocks. Dedicated Nodes for Elysium should be confirmed with the Chainstack team, as public pages are not consistent on them.

Fit by workload:

• Trading bots and market-making AMMs: Good — RPS tiers up to 600 and a flat-fee Unlimited Node add-on suit a quote loop, though no Elysium latency figures are published and Dedicated Nodes are unconfirmed.
• DeFi development, tracing and analytics: Excellent — the full EVM surface plus debug_* back to genesis on paid plans for debugging reverts.

Kinetiq public RPC

The Kinetiq public RPC (https://testnet-rpc.elysium.kinetiq.xyz) is the free, shared Elysium Testnet endpoint published in Kinetiq’s own docs alongside chain ID 99801, a block explorer, a faucet, and a bridge. It is an obvious starting point for first deployments, and it answered eth_chainId with 0x185d9, which is 99801, in our check on October 9, 2026.

It needs no account and no billing. Kinetiq’s docs list the testnet faucet and a bridge from HyperEVM Testnet on the same site, so a new account can be funded without leaving the ecosystem.

Limitations: It is a shared public endpoint, not a service with a stated SLA, rate-limit schedule, or support channel in the Kinetiq docs we reviewed. A debug_traceTransaction call returned -32401 authenticated API key required for method on October 9, 2026, so tracing is out of reach without a key. Kinetiq has not published a mainnet endpoint, and a free shared endpoint is not a plan for production traffic.

Fit by workload:

• Trading bots and market-making AMMs: Limited — no documented rate limits or SLA on a shared endpoint, so use it to prototype, not to run a strategy.
• DeFi development, tracing and analytics: Good for a first deployment and quick reads, but debug_* is gated behind a key.

Alchemy

Alchemy lists Elysium Testnet (chain ID 99801, HYPE as the native token) in its chain directory with HTTPS and WebSocket endpoints on elysium-testnet.g.alchemy.com, available with an Alchemy API key. Its page lists the RPC API and WebSockets for Elysium, and presents Debug, Trace, Token, NFT, and webhook products as request-support items.

Pricing is compute-unit based. The pricing page shows a free plan with 30M compute units per month and 15 requests per second, and a Pay As You Go plan at $0.525 per million CUs with 300 requests per second. Method weights vary: the general EVM table lists eth_blockNumber at 10 CU, eth_call at 26, eth_getLogs at 60, and debug_traceTransaction at 40. At $31.50 per million eth_getLogs calls, Alchemy costs roughly twice Chainstack’s Growth overage rate ($15) for a query near the chain tip. A fromBlock 127 or more blocks behind the tip bills as archive at 2 RU, and on Elysium that is only about 15 seconds of chain time, so most backfills cost about $30 per million at the Growth overage rate, close to Alchemy’s price. Run your own numbers before committing. Enterprise customers get signed SLAs and larger eth_getLogs ranges.

Limitations: Elysium support is testnet-only and limited to standard RPC and WebSockets on the chain page. Debug and Trace are shown as request-support items rather than self-serve features, and the page does not document dedicated infrastructure or Elysium-specific rate limits. Alchemy’s pricing page does not state whether the free allowance is permanent.

Fit by workload:

• Trading bots and market-making AMMs: Moderate — 300 RPS on pay-as-you-go, but no Elysium-specific latency or limits are documented.
• DeFi development, tracing and analytics: Good for deployment and reads, limited for tracing until Debug and Trace are confirmed for Elysium.

Getting started with Elysium on Chainstack

Deploy an Elysium Testnet endpoint in a few steps:

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 (Mainnet is not available yet)
5. Deploy the node
6. Open Access and credentials and copy your HTTPS and WebSocket endpoints

Then connect with ethers.js, following the Elysium tooling documentation:

const { JsonRpcProvider, formatEther } = require("ethers");

const provider = new JsonRpcProvider("YOUR_CHAINSTACK_ENDPOINT");

async function main() {
  const network = await provider.getNetwork();
  console.log("Chain ID:", network.chainId.toString()); // 99801 on Elysium Testnet

  const balance = await provider.getBalance("YOUR_WALLET_ADDRESS");
  console.log("Balance:", formatEther(balance), "HYPE"); // HYPE is the gas token
}

main();

📖 For the full integration guide covering MetaMask, viem, web3.py, Foundry, and Hardhat, see the Chainstack Elysium tooling documentation.

Need testnet HYPE? Kinetiq runs an Elysium testnet faucet, and you can also bridge testnet HYPE from HyperEVM Testnet. For heavier throughput, add the Unlimited Node add-on to a node on the Growth plan or above.

🤖 You can also access Chainstack Elysium RPC directly from Claude Code, Cursor, Codex, Windsurf, Gemini CLI, GitHub Copilot, Antigravity, Claude.ai, or ChatGPT using Chainstack MCP. For a fuller agent stack — MCP, the Chainstack skill, llms.txt for context ingestion, and WebMCP for agentic browsers — see the Chainstack Agents page.

Conclusion

The deciding question for Elysium in 2026 is how fast and how steadily your requests land on a chain built for sub-second trading. A free endpoint is fine for the first deployment, but once you run quote loops or need debug_* traces on 100–200 ms blocks, request ceilings, tiering and per-method cost matter more than anything else.

• First deployments and quick reads: Kinetiq public RPC or a free Chainstack Developer plan.
• Trading bots and market making: Chainstack on Growth or above, with the Unlimited Node add-on for flat-fee throughput, after you benchmark p95 latency yourself.
• Tracing, archive reads and analytics: Chainstack on the Growth plan or above.
• Teams already standardized on Alchemy: Alchemy’s Elysium testnet endpoint for standard RPC and WebSockets, with Debug and Trace on request.
• Mainnet planning: revisit this list once Kinetiq publishes a launch date and chain ID.

Frequently asked questions

Q: Can I track pending transactions on Elysium?

No. Elysium runs a single sequencer with no public mempool, so eth_subscribe("newPendingTransactions") and eth_newPendingTransactionFilter return an ID but never deliver a transaction. Subscribe to newHeads or logs over WebSocket, or poll receipts, instead.

Q: Which provider is best for free Elysium testing?

For a first deployment, the Kinetiq public RPC needs no account, and Chainstack’s Developer plan adds a private endpoint with 3M RU per month and 25 RPS. Alchemy’s pricing page lists a free plan with 30M compute units per month. If you need debug_* tracing, plan for Chainstack’s Growth plan.

Q: What happens when Elysium mainnet launches?

Kinetiq has not published a mainnet date or chain ID, and its docs say a HyperCore market-data precompile and a CoreWriter predeploy are expected about four weeks after mainnet through an ArbOS upgrade. Chainstack says it will add Mainnet support once Kinetiq confirms the details. Plan on deploying a separate mainnet node when that happens rather than reusing testnet endpoints.

Q: How fast is Elysium, and how should I test latency?

Kinetiq targets 100–200 ms blocks, and the testnet averaged about 121 ms per block over its last 100,000 blocks when we measured on October 9, 2026. compare.chainstack.com does not list Elysium yet, so measure p95 latency yourself from your target region against each provider, using one light and one heavy method.

Q: Which Elysium providers meet enterprise compliance requirements?

Chainstack holds SOC 2 Type II and ISO 27001 certifications and offers an Enterprise plan with a custom SLA. Alchemy lists signed SLAs on its Enterprise plan, and the Kinetiq public RPC documents no SLA or certification. Check each vendor’s trust page directly before a procurement decision.

Q: How does Elysium RPC pricing compare across providers?

Chainstack charges 1 RU per full request and 2 RU for archive and debug requests. Alchemy weights each method, with eth_getLogs at 60 CU in its general EVM table. At the published rates, one million eth_getLogs calls cost about $15 on Chainstack at the Growth overage rate when fromBlock is within 127 blocks of the tip and about $30 beyond that, against about $31.50 on Alchemy Pay As You Go, so model your own method mix before you scale.

Additional resources

• What is Elysium? Kinetiq’s Hyperliquid L2 explained
• Chainstack introduces Elysium Testnet support
• Elysium: trace internal calls and HYPE transfers — Chainstack Docs
• Elysium by Kinetiq: official site and testnet portal
• Chainstack pricing