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 launched Elysium Mainnet on November 9, 2026, after a public testnet that opened on September 22, 2026.

Elysium’s design shapes what a provider needs to offer. 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 five options with a confirmed Elysium page or docs entry as of November 9, 2026: Chainstack, Goldsky Edge RPC, Kinetiq’s public endpoint, Alchemy, and Quicknode. 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 the Elysium chain yourself, as the Chainstack docs show.

Why RPC provider choice matters for Elysium

A new chain gives you little to lean on. Kinetiq says specifications, parameters, and timelines may still be refined after 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 documents 100 ms canonical blocks. A 10,000-block log query therefore covers roughly 17 to 33 minutes of chain time, 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 over each chain’s last 100,000 blocks on October 9, 2026; the Elysium figure predates mainnet launch.

• 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 young mainnet.
• 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 November 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	Mainnet, Testnet
Goldsky Edge RPC	Flat per request ($5.00 per 1M on Scale)	Yes (1M requests per month)	Enterprise only (dedicated CDN node)	Full archive and trace per product page; HTTPS only	Mainnet
Kinetiq public RPC	Free, shared	Yes	Not offered in docs	debug_* requires an API key	Mainnet, Testnet
Alchemy	Method-weighted compute units	Yes (free plan)	Not documented for Elysium	Debug and Trace API listed as request-support	Mainnet, Testnet
Quicknode	Method-weighted API credits (Build $49/mo for 80M)	Yes (one-month free trial)	Enterprise only (custom)	Archive on all plans; trace and debug from Build up	Testnet (mainnet not listed yet)

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
Goldsky Edge RPC (Scale)	1 request, no method weighting	$5.00
Kinetiq public RPC	Not metered	Free, rate-limited
Alchemy (Pay As You Go)	60 CU in Alchemy’s general EVM table	$31.50
Quicknode (Build)	Method-weighted API credits; eth_getLogs weight not confirmed here	$0.62 per 1M additional credits, multiplied by the method’s credit weight

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 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, debug_* methods are gated behind an API key. 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 13 to 25 seconds at Elysium’s 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, 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, arrive in an ArbOS upgrade about four weeks after mainnet launch.

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 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 Mainnet and Testnet on Nitro, the Arbitrum client, through Global Nodes with HTTPS and WebSocket endpoints, archive mode, and debug and trace on paid plans.

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: 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.

Goldsky Edge RPC

Goldsky documents Elysium in its Edge RPC docs, which list Elysium Mainnet. The testnet entry is inconsistent between its chains page and its Edge RPC guide, so confirm testnet support before you rely on it. Edge RPC is served over HTTPS only: there is no WebSocket endpoint and eth_subscribe is not supported. Goldsky’s product page lists full archive access and debug_* and trace_* support, and the Elysium guide caps eth_getLogs at 20,000 blocks.

Pricing is request-based with no compute-unit weighting. The pricing page shows a free Starter plan with 1M requests per month, 6,000 requests per minute and 500 requests per minute per IP, and a Scale plan at $5.00 per million requests with unlimited endpoints, which is below the Chainstack and Alchemy eth_getLogs figures above. A dedicated CDN node is listed on Enterprise only, and Goldsky lists SOC 2 Type II compliance on its site.

Limitations: HTTPS only, so bots that need push-style block or log events have to poll, and archive and trace support comes from the general product page rather than an Elysium-specific statement.

Fit by workload:

• Trading bots and market-making AMMs: Limited — no WebSocket or eth_subscribe, so on 100–200 ms blocks the only option is polling.
• DeFi development, tracing and analytics: Good — archive and trace are listed, pricing is flat per request, and the 20,000-block eth_getLogs cap on Elysium is generous for backfills.

Kinetiq public RPC

The Kinetiq public RPC is the free, shared Elysium endpoint published in Kinetiq’s own docs alongside the chain ID, a block explorer, a faucet, and a bridge; the testnet endpoint is https://testnet-rpc.elysium.kinetiq.xyz (chain ID 99801). It is an obvious starting point for first deployments.

It needs no account and no billing. Kinetiq’s docs list a testnet faucet and a bridge from HyperEVM 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. debug_traceTransaction requires an API key on the public endpoint, so tracing is out of reach without one. 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 (HYPE as the native token) in its chain directory with HTTPS and WebSocket endpoints on elysium-mainnet.g.alchemy.com (mainnet) and elysium-testnet.g.alchemy.com (testnet), 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 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.

Quicknode

Quicknode has an Elysium chain page and a docs entry. The docs list Elysium Testnet (chain ID 99801) with HTTPS and WebSocket endpoints, and mention debug methods and Arbitrum Nitro methods for parent-chain data. When we checked on November 9, 2026, they did not list Elysium Mainnet, so confirm mainnet availability before you plan around it. The docs also warn that pending-transaction filters and subscriptions can return an ID without delivering transactions, so use block and log subscriptions.

Pricing is credit-based, and the figures on Quicknode’s pricing page are generic to all chains, not specific to Elysium. They show a one-month free trial with 10M API credits and 15 requests per second, Build at $49 per month with 80M credits, 50 requests per second and $0.62 per million additional credits, and Accelerate at $249 per month with 450M credits and 125 requests per second. The pricing table lists archive data on every plan and trace and debug from Build upward, and dedicated clusters on Enterprise only. Quicknode’s chain page states SOC 2 Type II and ISO 27001; check its trust page before a procurement decision.

Limitations: The free plan is a one-month trial rather than a permanent tier, credits are method-weighted so trace-heavy workloads are harder to budget, the eth_getLogs credit weight is not confirmed for Elysium here, and Elysium Mainnet is not listed in its docs yet.

Fit by workload:

• Trading bots and market-making AMMs: Moderate — up to 125 requests per second on Accelerate and dedicated clusters on Enterprise, but no Elysium-specific latency is documented and mainnet is not listed yet.
• DeFi development, tracing and analytics: Good on testnet from the Build plan, with debug methods and archive data, though credit weights make heavy tracing harder to budget.

Getting started with Elysium on Chainstack

Deploy an Elysium 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 Mainnet, or Elysium Testnet for development and testing
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()); 

  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 HYPE? Bridge HYPE from HyperEVM to Elysium 1:1 through Kinetiq’s bridge. For testnet, 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 endpoint for standard RPC and WebSockets, with Debug and Trace on request.
• Production on mainnet: deploy a separate mainnet node for production, and keep a testnet node for development and testing.

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. Goldsky’s Starter plan includes 1M requests per month, and Quicknode’s free plan is a one-month trial.

Q: What changed when Elysium mainnet launched?

Mainnet launched on November 9, 2026. Its docs say a HyperCore market-data precompile and a CoreWriter predeploy are expected about four weeks after mainnet through an ArbOS upgrade. Chainstack serves Elysium Mainnet through Global Nodes.

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

Kinetiq targets 100–200 ms blocks and documents 100 ms canonical blocks. 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. Quicknode’s chain page lists SOC 2 Type II and ISO 27001, and Goldsky lists SOC 2 Type II on its site.

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. Quicknode charges method-weighted credits (Build is $49 per month for 80M credits), and Goldsky charges $5.00 per million requests on Scale with no method weighting.

Additional resources

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