Blockchain infrastructure

Top 9 Ethereum RPC Providers (2026)

Compare QuickNode, Infura, Alchemy, Chainstack and five more on Ethereum RPC, private routing, WebSockets, archive access and pricing.

Tools at a glance

9 listed tools
  1. QuickNode
  2. Infura
  3. Alchemy
  4. Tenderly
  5. GetBlock
  6. Chainstack
  7. Ankr
  8. dRPC
  9. NodeReal

Ethereum RPC providers connect wallets, trading bots and execution systems to blockchain data and transaction submission, but they differ in pending-transaction feeds, historical state, simulation, private routing and billing. For active traders, the choice depends on whether the priority is live monitoring, transaction submission, MEV protection or historical analysis. This comparison is based on each provider's official documentation and published features, checked in November 2026; we have not tested the tools hands-on.

Which one to pick

  • Need one default endpoint for an Ethereum trading bot: QuickNode, with HTTP and WebSocket access, method-based credits and MEV-protected transaction routing on standard plans.
  • Need private transaction routing with a free starting plan: Chainstack, which includes Ethereum MEV Protection on its Developer plan.
  • Need RPC alongside indexed blockchain data: Alchemy, with token, transfer and wallet APIs plus private transaction routing when all write traffic stays on its infrastructure.
  • Need transaction simulation and execution analysis: Tenderly, with custom simulation, gas-estimation and tracing methods.
  • Need archive access and configurable infrastructure: GetBlock, with regional endpoint selection, shared and dedicated nodes, and protected Ethereum RPC.
  • Need alternative billing or multi-provider routing: Infura for daily credit quotas, Ankr for per-request EVM pricing, dRPC for distributed upstream routing, or NodeReal for free and paid MegaNode plans.

Compare Ethereum RPC features for live trading

ToolType / fitTrader-relevant accessPrice
QuickNodeManaged Ethereum and multichain RPCHTTP/WSS, private relay, archive, Trace and Debug, fixed-RPS optionOne-month trial; paid from $49/mo
InfuraStandard JSON-RPC infrastructureHTTP/WSS, Ethereum archive, subscriptions, daily credit quotasFree; Developer $50/mo; Team $225/mo
AlchemyRPC and indexed developer APIsArchive, Smart WebSockets, paid Trace and Debug, private transactionsFree 30M CU/mo; PAYG $0.525/1M CU
TenderlyRPC with transaction toolingHTTP/WSS, transaction simulation, gas estimation and decoded tracesPaid Node RPC; TU-based billing
GetBlockShared and dedicated nodesWSS, archive, Ethereum MEV-protected endpoint, regional selectionFree; shared plans from $39/mo
ChainstackManaged global and dedicated nodesWSS, archive and Trace on Growth+, Ethereum MEV routingFree; Growth $49/mo
AnkrMultichain Node APIArchive, Premium WSS, Trace and DebugFree tiers; $0.00002 per EVM HTTPS request on PAYG
dRPCDistributed multi-provider RPC gatewayPaid pending filters, WSS, archive, Trace and DebugFree; PAYG $6/1M requests; Pro $49/mo
NodeRealMegaNode managed RPCHTTPS/WSS, Ethereum archive, Debug API on paid tiersFree; Growth $39/mo

The tools

QuickNode

Configurable Ethereum trading infrastructure

Type / fitManaged Ethereum and multichain RPCPriceOne-month trial; paid from $49/mo

QuickNode exposes Ethereum JSON-RPC through HTTP and WSS for mainnet, Sepolia and Hoodi. Its method-specific API credits mean simple reads and heavier trace or log operations consume different amounts. The platform also provides a fixed-RPS billing option for individual endpoints. Its Ethereum documentation covers archive, Trace and Debug APIs. Standard plans include private transaction routing, but failed private submissions are not automatically retried through the public mempool. The Build plan costs $49 monthly or $34 per month with annual billing.

Choose it when you want a managed Ethereum endpoint with documented private submission and configurable capacity.

Watch out for capped WebSocket response sizes.

Infura

Ethereum JSON-RPC with daily credit quotas

Type / fitStandard JSON-RPC infrastructurePriceFree; Developer $50/mo; Team $225/mo

Infura supplies HTTPS and WebSocket endpoints for Ethereum mainnet, Hoodi and Sepolia, with archive access available for Ethereum. Its billing uses a daily pool of credits weighted by RPC method. Subscriptions, unsubscriptions and incoming WebSocket events also consume credits. The published free allowance is three million credits per day, while Developer and Team plans provide higher daily quotas. Developer costs $50 per month and Team costs $225 per month.

Choose it when your application uses conventional Ethereum JSON-RPC and benefits from a clearly defined daily usage allowance.

Watch out for WebSocket connections being terminated when the daily allowance runs out.

Alchemy

RPC combined with blockchain data APIs

Type / fitRPC and indexed developer APIsPriceFree 30M CU/mo; PAYG $0.525/1M CU

Alchemy combines Node API access with indexed services for tokens, transfers, NFTs, wallets and webhooks. Ethereum users get archive data and Smart WebSockets, while Debug and Trace APIs are available on paid plans. The free allowance is 30 million compute units monthly, with Pay as You Go priced at $0.525 per million CUs. Throughput capacity can add to the bill. Alchemy also provides private transaction routing on Ethereum without an extra routing charge, provided all copies of a transaction are submitted exclusively through its infrastructure.

Choose it when you want RPC and indexed data services under one account and can centralise transaction writes.

Watch out for method-dependent CU use and throughput-capacity charges.

Tenderly

Simulation and transaction inspection

Type / fitRPC with transaction toolingPricePaid Node RPC; TU-based billing

Tenderly Node RPC connects production EVM infrastructure with its simulation and debugging environment. Its endpoints support HTTP and WebSocket requests across more than 70 EVM networks. Custom methods include tenderly_simulateTransaction, tenderly_simulateBundle, tenderly_estimateGas and tenderly_traceTransaction. Usage is measured in Tenderly Units, with different weights for reads, writes, computation and tracing. Node RPC is available only on paid plans, and customers must contact sales to enable it. The documentation publishes method weights rather than a standard self-service dollar subscription.

Choose it when transaction simulation, gas estimation and decoded execution traces are central to your trading workflow.

Watch out for sales-enabled production access and the lack of JSON-RPC batching over WebSockets.

GetBlock

Archive access and regional endpoint configuration

Type / fitShared and dedicated nodesPriceFree; shared plans from $39/mo

GetBlock lets customers configure Ethereum endpoints with full or archive access, select JSON-RPC or WebSocket interfaces and choose server locations including Frankfurt, Singapore and New York. Its Ethereum offering also lists MEV-protected RPC endpoints. Shared subscriptions start at $39 monthly on the published product page. Archive requests on shared archive endpoints receive a two-times compute-unit multiplier, including calls that do not actually require historical state.

Choose it when you need historical Ethereum queries, regional endpoint choices and a configurable transaction-protection option.

Watch out for the higher CU consumption associated with archive endpoints; keep routine live queries on a separate full-node endpoint.

Chainstack

Ethereum RPC with built-in MEV protection

Type / fitManaged global and dedicated nodesPriceFree; Growth $49/mo

Chainstack offers managed Ethereum endpoints over HTTPS and WebSocket, including mainnet and testnet access. Its Ethereum MEV Protection service privately routes signed transactions to block builders rather than broadcasting them to the public mempool. The feature is available on Ethereum mainnet Global Nodes, including the free Developer plan. Growth adds historical data and Debug and Trace APIs. That plan costs $49 monthly or $40 per month with annual billing. If private submission fails, Chainstack returns an error rather than automatically broadcasting the transaction publicly.

Choose it when private Ethereum transaction submission and a clear upgrade path for archive and tracing access matter to your workflow.

Watch out for pending-transaction monitoring: before inclusion, the transaction hash is retrievable only through the submitting Chainstack endpoint.

Ankr

Multichain RPC with per-request pricing

Type / fitMultichain Node APIPriceFree tiers; $0.00002 per EVM HTTPS request on PAYG

Ankr Node API provides standard JSON-RPC access to Ethereum and other supported networks. Its Public and Freemium plans provide free access, while Premium unlocks WebSocket connectivity and Trace and Debug methods. Archive data is listed across service tiers. Premium PAYG pricing assigns 200 API credits to an EVM-compatible HTTPS request, equivalent to $0.00002 at the published credit rate. Freemium includes a monthly credit allowance, but requests still operate under public rate limits.

Choose it when you want multichain connectivity with a published per-request EVM cost.

Watch out for valid but unsupported RPC methods: Ankr charges the default credit amount for them.

dRPC

RPC requests routed across independent providers

Type / fitDistributed multi-provider RPC gatewayPriceFree; PAYG $6/1M requests; Pro $49/mo

dRPC operates as a gateway to independent node operators and public infrastructure. Its routing layer considers provider location, capacity, current chain height and supported RPC methods when selecting an upstream. The Ethereum API documents standard transactions, subscriptions, pending-transaction filters and tracing methods. Free accounts use public nodes, while paid plans add archive, WebSocket, Debug and Trace access. Published options include PAYG at $6 per million requests, Pro at $49 monthly and Scale at $199 monthly. Monthly CU allowances reset without carrying unused capacity forward.

Choose it when you prefer a gateway that distributes requests across independent node infrastructure rather than depending on one upstream operator.

Watch out for the free plan's restricted capabilities and the need to monitor monthly CU balances and request limits.

NodeReal

Ethereum MegaNode with archive support

Type / fitMegaNode managed RPCPriceFree; Growth $39/mo

NodeReal's MegaNode provides Ethereum JSON-RPC through HTTPS and WSS. Its archive documentation covers historical Ethereum mainnet state, with archive access available across service tiers without a separate archive fee. The pricing page lists Free, Growth, Team and Business plans. Growth costs $39 monthly or $31 per month with annual billing. It includes 500 million monthly compute units, while Debug API access is available on upgraded plans. NodeReal's documentation also notes that archive access is not available for testnets.

Choose it when you need a free starting point, Ethereum historical state and an upgrade path to transaction debugging.

Watch out for CUPS limits, which cap throughput independently of the monthly CU allowance.

How to set up an Ethereum RPC for live trading

  1. Map your RPC workload. List the calls your bot actually makes. These may include eth_call for contract reads, eth_getLogs for pool events, eth_subscribe for new blocks and logs, pending-transaction filters for mempool monitoring, and eth_sendRawTransaction for broadcasting signed transactions. Check whether each provider supports the exact methods you need.
  2. Create an authenticated Ethereum endpoint. Register with QuickNode, Infura, Alchemy, Chainstack, GetBlock, Ankr, dRPC or NodeReal. Select Ethereum mainnet and create HTTP and WSS connections where supported. Choose a server region close to your trading infrastructure, and create separate credentials for different applications.
  3. Verify subscriptions and pending data. Establish a WebSocket connection and subscribe to newHeads and relevant contract logs. Test pending-transaction methods separately. dRPC, for instance, documents pending-transaction filters as paid-tier functionality. Check reconnection behaviour, notification continuity and rate limits rather than assuming every provider implements subscriptions identically.
  4. Benchmark the actual workload. Run the same requests from the server location where your trading bot operates. Record P50 and P95 response times, stale-head lag, HTTP errors, rate-limit responses, WebSocket disconnects and missed notifications. Keep the request mix and concurrency consistent when comparing providers.
  5. Calculate the real usage cost. Estimate consumption using your provider's billing system: QuickNode API credits, Infura daily credits, Alchemy compute units, Ankr per-request charges or dRPC compute units. Include WebSocket events, historical calls and tracing. Test archive queries separately. GetBlock applies a two-times CU multiplier to shared archive endpoints, while Infura currently charges the same credits for archive and ordinary requests.
  6. Simulate transactions before signing. Use eth_call and eth_estimateGas to check contract interactions. Tenderly can simulate individual transactions or bundles and expose execution traces. Apply appropriate slippage limits, minimum-output values and transaction deadlines before allowing the signer to approve a trade.
  7. Configure the transaction submission path. If MEV protection is required, explicitly select a provider's protected endpoint or enable its documented routing feature. QuickNode, Chainstack, Alchemy and GetBlock document Ethereum transaction-protection options. Check whether a failed private submission is rejected or retried, and send writes through the intended protected route. After submission, track the returned hash and query eth_getTransactionReceipt for inclusion and execution status.

Worked example (illustrative): Assume a trading bot makes 20,000 contract reads, 2,000 log queries and 300 signed swaps daily. Its operator compares the same workload across providers, recording compute consumption, P95 response time and error rates from one region. After simulating a 0.4 ETH swap and setting a 0.5% minimum-output tolerance, the bot submits the signed transaction through one protected endpoint and monitors its hash and receipt.

RPC and transaction execution risks

A private API-key endpoint does not automatically make transactions private: only an explicitly documented private-routing mechanism changes their exposure to the public mempool. Private submission can also change how pending transactions appear in monitoring tools, and a failed relay may not fall back to ordinary broadcasting. Keep slippage limits, deadlines, nonce management and transaction simulation in place, and never expose API credentials or signing keys in browser code, logs or public repositories.

Frequently asked questions

Does a private Ethereum RPC prevent sandwich attacks?

No. A private endpoint usually means an authenticated connection reserved for your account. Protection against public-mempool exposure requires an explicit private transaction-routing feature.

Can an Ethereum RPC provider show pending transactions?

Some providers support pending-transaction notifications through eth_subscribe or eth_newPendingTransactionFilter. Availability varies by provider and plan, and a single endpoint does not necessarily expose every pending transaction circulating across Ethereum.

Do trading bots need archive RPC access?

Not necessarily for live contract reads, block monitoring or transaction submission. Archive access becomes important when querying historical account balances, contract storage or execution state at older block heights.

Can I use two RPC providers for transaction redundancy?

Yes, but distinguish read redundancy from write redundancy. Broadcasting identical signed transactions through multiple providers can expose a transaction to the public mempool even when the primary provider uses private routing.

Does an RPC provider sign Ethereum transactions?

Normally, no. Your wallet or external signer creates the signed transaction, and the RPC provider relays it through eth_sendRawTransaction. Your private signing key should remain outside the provider's infrastructure.

How should I compare Ethereum RPC latency?

Measure from your actual execution region using identical methods, concurrency and request volumes. Compare P50 and P95 response times, head lag, WebSocket continuity and error rates separately; transaction inclusion time is a different measurement from an RPC response.

Sources

Show all 24 sources