Top 7 Ethereum RPC providers for DeFi in 2026

Ethereum remains the base settlement layer for on-chain finance, with tens of billions of dollars in DeFi value locked across protocols including Aave, Uniswap, Curve, and Morpho — track the current figure on DefiLlama’s Ethereum chain page. The 2026 shift is who is now depositing that capital: BlackRock’s tokenized funds crossed $2.93 billion on-chain, with Ethereum holding the largest single-chain share at $1.1 billion, Securitize built regulated tokenization infrastructure directly on Ethereum, and MiCA’s full-scope enforcement in Europe alongside the GENIUS Act in the United States extended compliance obligations to infrastructure vendors, not just the protocols themselves.

For institutional teams — asset managers monitoring collateral positions in real time, compliance officers reconstructing execution traces for regulators, or protocol treasuries running 24/7 settlement infrastructure — RPC provider selection now carries the same due diligence weight as choosing a prime broker. A shared endpoint with opaque rate limiting, no contractual uptime guarantee, and an uncertified security posture fails the vendor assessment most compliance and legal teams now run before a contract gets signed.

This guide compares seven providers for institutional DeFi on Ethereum, covering the RPC methods this workload actually calls, the infrastructure and compliance certifications that separate production-grade from merely adequate, and where each provider fits.

💡 Already using Chainstack? Jump straight to the Ethereum tooling docs or deploy your endpoint in minutes at Chainstack Ethereum nodes.

Institutional DeFi on Ethereum: RPC requirements

Latency profile

Institutional DeFi sits between two extremes. It isn’t high-frequency trading — Aave collateral monitoring on 12-second block intervals tolerates response times that would sink an MEV bot. But it isn’t batch analytics either. Liquidation monitoring, position health alerts, and real-time settlement confirmation all need consistent sub-100ms endpoint latency. The number that matters is p95, not the average: a provider delivering 40ms average but 2,000ms at the 95th percentile will miss liquidation windows during precisely the market conditions when positions go underwater.

During volatility events — a collateral ratio breach cascading through Aave, or a Curve pool depeg — transaction volume on Ethereum spikes sharply. An endpoint that degrades gracefully under that load is a distinguishing feature, not something every provider has solved.

Throughput requirements

A single institutional-scale Aave deployment monitoring five vaults, streaming event subscriptions across three contracts, and verifying receipts for every transaction generates 200–500 RPS in steady state. Add batch position health checks on block finalization and periodic historical reads for reconciliation, and 1,000 RPS becomes a reasonable ceiling for a modestly complex institutional stack. Shared endpoint plans with hard rate limits — or providers that quietly throttle under load — fail exactly when market conditions demand the most throughput.

Key RPC methods

The methods that define institutional DeFi on Ethereum:

• eth_call — Executes a read-only call against the EVM without submitting a transaction. The primary method for querying protocol state: Aave position health factors, Uniswap slot0 prices, Morpho market parameters. Runs on every block in any position-monitoring system. Doesn’t require archive for queries against "latest" — only for a historical blockNumber.
• eth_getLogs — Returns emitted events matching a filter: deposits, withdrawals, liquidations, transfers. Doesn’t require an archive node for recent block ranges; it works on a standard full node. Archive is only needed once the range extends past the node’s state-retention window — commonly around 127 blocks for a pruned full node, further back for archive.
• eth_getTransactionReceipt — Returns execution status, gas consumed, and emitted logs for a confirmed transaction. The canonical method for settlement finality verification: proof that a deposit or withdrawal executed, plus the log events showing it.
• eth_subscribe — WebSocket-only method for real-time subscriptions: new block headers, pending transactions, or filtered log events. Any latency-sensitive institutional process — liquidation monitoring, oracle price tracking — should use this instead of polling with eth_getLogs. Requires a WebSocket endpoint, not HTTP.
• debug_traceTransaction — Returns a complete EVM execution trace for a historical transaction: every opcode, every state change, every call frame. Requires an archive node with debug enabled. The compliance team’s primary method for reconstructing exactly what happened in a transaction for regulatory reporting or incident response.
• trace_transaction / trace_block — Parity-style trace methods returning internal call structure and value transfers, including calls that never appear in logs. Require archive plus trace enabled. Used by analytics pipelines and compliance teams that need a structured account of internal transfers a standard receipt omits.
• eth_getBalance / eth_getStorageAt at a historical blockNumber — Historical state queries for reconciliation: an address’s balance, or a storage slot’s value, at a specific past block. Require archive access. These, not eth_getLogs, are what actually drives archive-endpoint demand in institutional deployments.

Infrastructure requirements

Institutional deployments belong on Dedicated Nodes, not shared pools. The issue is resource contention: a shared endpoint serves thousands of concurrent projects, so p95 latency during a major DeFi event reflects everyone else’s load on the same platform, not just yours. Dedicated Nodes provide an isolated, predictable capacity ceiling independent of other tenants.

Geographic proximity matters too. Running a liquidation bot colocated with your node in the same AWS us-east-1 or eu-west-1 datacenter cuts round-trip latency by tens of milliseconds versus cross-region calls — a real advantage on block timescales.

WebSocket availability is non-negotiable for eth_subscribe. Not every provider exposes WebSocket endpoints on every plan; confirm it before committing to a provider for an event-driven architecture.

MEV exposure is also worth a line for institutional DeFi specifically. Large collateral deposits, withdrawals, and liquidation-triggering transactions are exactly the kind of value-bearing calls that front-running and sandwich strategies target. Chainstack enables MEV protection by default on Ethereum, BNB Smart Chain, Arbitrum, and Base Global Nodes at deployment (it can be disabled from the node’s Add-ons tab); check whether a given provider routes through a private mempool or equivalent protection by default, as an opt-in add-on, or not at all before assuming a submitted transaction is shielded.

For a full index of Ethereum JSON-RPC methods, including the debug and trace namespaces, see the Ethereum API reference.

Provider comparison for institutional DeFi

The table below summarizes public positioning as of August 2026.

Provider	Pricing model	Free tier	Dedicated nodes	Archive & trace	Compliance
Chainstack	RU-based, flat	3M RU/mo, 25 RPS	Yes, from $0.50/hr	Yes, included on paid plans	SOC 2 Type II and ISO 27001
RouteMesh	Per-request, routing layer	Free community endpoint	No — routes to upstream providers	Depends on upstream provider	Not independently published
Uniblock	Per-request, routing layer	Free tier available	No — routes to upstream providers	Depends on upstream provider	Not independently published
Blockdaemon	Custom / quote-based	Not self-serve	Yes, custom/on-premise	Not publicly detailed	SOC 2 Type II and ISO 27001
Infura	Credit-based	3M credits/day	No	Yes (Developer plan+)	Not published
Alchemy	CU-based	30M CU/mo	No standard tier	Yes	SOC 2 Type II (no published ISO 27001)
Quicknode	Credit-based	10M credits (trial only)	Yes (enterprise)	Yes (paid plans)	SOC 2 Type II + ISO 27001 (enterprise)

Chainstack

Chainstack runs Ethereum Dedicated Nodes with archive and trace access included by default, SOC 2 Type II and ISO 27001 certification, and a flat Request Unit pricing model that charges the same unit for debug_traceTransaction as for eth_blockNumber — a combination built around institutional compliance and audit workloads specifically.

The billing model matters at scale: full-node requests cost 1 RU, archive requests cost 2 RU, and there are no per-method multipliers layered on top. Plans run from the free Developer tier (3M RU/month, 25 RPS) through Growth ($49/month, 20M RU, 250 RPS) and Pro ($199/month, 80M RU, 400 RPS) to Business ($499/month, 200M RU, 600 RPS) and Enterprise (from $990/month, 400M+ RU, unlimited RPS). Debug and trace APIs are available from Growth and above.

Dedicated Nodes start at $0.50/hour for compute plus $0.01 per 20 GB-hour for archive storage, and include the full debug and trace namespaces with no extra configuration — the foundation for compliance audit trails and historical reconciliation. The Unlimited Node add-on layers flat-rate RPS tiers on top (25 RPS at $149/month up to 500 RPS at $3,199/month), which turns infrastructure into a single predictable line item — useful when procurement and finance teams are reviewing the vendor contract, not just engineering.

The SOC 2 Type II and ISO 27001 certifications are audited assessments over a sustained period, not self-reported questionnaires or point-in-time snapshots — the standard that actually satisfies a regulated vendor-attestation review. The Enterprise tier adds SSO, granular role-based permissions, and a contractual response SLA (as fast as under 1 hour on the Premium support tier, per the enterprise support and SLA terms), plus a dedicated account team — the difference between a manageable incident and a regulatory notification when live capital is involved. Teams that need the node inside their own environment for data-sovereignty reasons can also run Ethereum mainnet, Sepolia, or Hoodi on Self-Hosted using the Reth and Prysm client stack, alongside — not instead of — Dedicated Nodes.

Limitations: The free tier’s 25 RPS ceiling is low for institutional load testing; teams building out monitoring infrastructure reach it quickly. Archive storage pricing adds to Dedicated Node costs on long-running deployments and should be modeled in before committing to a configuration.

Fit for institutional DeFi:

• Archive & trace: Excellent — included on Dedicated Nodes with no extra configuration
• Dedicated throughput: Excellent — isolated capacity from $0.50/hour, plus flat-rate Unlimited Node tiers
• Compliance posture: Excellent — audited SOC 2 Type II and ISO 27001, contractual SLA on Enterprise
• Uptime SLA: Excellent — contractual terms available, with a dedicated account team on Enterprise

The code below shows a minimal institutional monitoring pattern used throughout this guide’s Getting started example: checking a position health factor on Aave V3.

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("YOUR_CHAINSTACK_ENDPOINT"))

# Aave V3 Pool contract on Ethereum mainnet
AAVE_V3_POOL = "YOUR_CONTRACT_ADDRESS"
POOL_ABI = [{
    "name": "getUserAccountData",
    "type": "function",
    "inputs": [{"name": "user", "type": "address"}],
    "outputs": [
        {"name": "totalCollateralBase", "type": "uint256"},
        {"name": "totalDebtBase", "type": "uint256"},
        {"name": "availableBorrowsBase", "type": "uint256"},
        {"name": "currentLiquidationThreshold", "type": "uint256"},
        {"name": "ltv", "type": "uint256"},
        {"name": "healthFactor", "type": "uint256"}
    ]
}]

pool = w3.eth.contract(address=AAVE_V3_POOL, abi=POOL_ABI)

def check_health_factor(address: str) -> float:
    data = pool.functions.getUserAccountData(address).call()
    return data[5] / 1e18  # 18-decimal fixed point

print(check_health_factor("YOUR_WALLET_ADDRESS"))

RouteMesh

RouteMesh is an intelligent RPC routing layer covering Ethereum mainnet and 1,000+ other EVM networks, aggregating multiple upstream providers behind a single endpoint with sub-10ms routing decisions, real-time provider health scoring, and automatic failover when an upstream node degrades or times out.

Pricing is per-request rather than compute-unit based, with no minimum commitment; a public community endpoint routes read-only Ethereum calls to public nodes at no cost, and paid tiers price by chain, method, and routing strategy. For institutional teams running redundant infrastructure across chains, the failover model — retrying against a different upstream, Chainstack among them, when one provider degrades — reduces the operational risk of a single vendor’s outage taking down a risk engine or settlement pipeline. Customers building on the platform include LI.FI, Vaults.fyi, and DAMM Capital.

Limitations: RouteMesh doesn’t operate its own archive or dedicated hardware — it routes to whichever upstream provider best serves a given request, so archive depth and trace-method availability depend on which backend answers the call. There’s no independently published SOC 2 or ISO 27001 for the routing layer itself; institutional teams should treat it as a resilience layer sitting in front of certified providers, not a certified vendor on its own.

Fit for institutional DeFi:

• Archive & trace: Moderate — inherited from whichever upstream handles the request, not something RouteMesh guarantees directly
• Dedicated throughput: Limited — the product is routing and failover, not isolated hardware
• Compliance posture: Moderate — no independent certification published; due diligence needs to cover the upstream providers it routes to as well
• Uptime SLA: Strong, in practice — multi-provider failover is itself a form of availability engineering, even without a formal contractual number

Uniblock

Uniblock is a managed multi-chain infrastructure layer spanning Ethereum and 300+ other blockchains through 55+ underlying RPC providers, offered across three tiers: Unified JSON-RPC for raw calls, higher-level Unified APIs for token, NFT, and webhook data, and Direct Provider APIs that pass straight through to a named upstream.

The webhook layer is the genuinely useful piece for institutional DeFi: event-driven updates pushed on address activity or contract events reduce the polling infrastructure a compliance or risk team would otherwise have to build and maintain themselves. Pooling 55+ underlying providers also means more aggregate rate-limit headroom than a single-provider account, which matters for burst-heavy monitoring workloads. Uniblock reports 4,000+ developers and 3,000+ projects on the platform, with named customers including Plume Network, Stellar, and Oku Trade, and raised $5.2M in March 2026.

Limitations: As with RouteMesh, Uniblock doesn’t publish its own SOC 2 or ISO 27001 certification, and the aggregation model gives institutional teams less direct control over node-level configuration — custom debug/trace toggles, specific archive retention windows — than a direct dedicated-node relationship would. Evaluate the certification posture of the specific upstream provider a request is likely to land on, not just Uniblock’s own marketing.

Fit for institutional DeFi:

• Archive & trace: Moderate — available through upstream providers, but not independently guaranteed at the Uniblock layer
• Dedicated throughput: Limited — pooled rate-limit headroom across providers, not isolated hardware
• Compliance posture: Moderate — the webhook and Unified API layer is a real differentiator for compliance event pipelines specifically, even without its own certification
• Uptime SLA: Good — automatic routing and failover across 55+ providers cushions any single upstream’s downtime

Blockdaemon

Blockdaemon is an institutional-focused infrastructure provider offering production Ethereum RPC endpoints alongside custody, staking, and MPC key management, built for the vendor due-diligence process regulated financial institutions run before signing an infrastructure contract.

Blockdaemon publishes SOC 2 Type II and ISO 27001 certification plus OFAC and NORS compliance screening, and states its stack is designed to pass due diligence from “the world’s most regulated institutions.” The company reports serving 400+ institutions with $110B+ in assets secured, with a client base that includes BNY Mellon, Goldman Sachs, JPMorgan, Citi, and Visa. On-premise deployment and governance controls are available for institutions that need the infrastructure inside their own perimeter rather than a shared cloud footprint.

Limitations: Pricing isn’t published — access goes through a sales conversation rather than a self-serve signup, so procurement teams can’t get a quote the way they can with a developer-first RPC provider. Per-method archive and trace availability also isn’t detailed publicly on Blockdaemon’s own documentation the way node-focused providers publish it; confirm archive depth and trace-method coverage directly with their team before committing to a compliance-critical audit workflow.

Fit for institutional DeFi:

• Archive & trace: Not publicly detailed — confirm directly for trace-heavy compliance workflows
• Dedicated throughput: Good — on-premise and custom infrastructure options exist for institutional-scale deployments
• Compliance posture: Excellent — audited SOC 2 Type II and ISO 27001, plus OFAC/NORS screening, serving Tier-1 banks today
• Uptime SLA: Custom — contractual terms negotiated per institutional engagement rather than a published tier

Infura

Infura, now operating as MetaMask Developer and backed by ConsenSys, has one of the longest institutional track records in the Ethereum ecosystem. The free Core plan provides 3M credits per day — a meaningful recurring allowance, not a one-time trial. Archive access is available on all plans, which is unusual: a Core-tier account can run eth_getBalance at a historical block without upgrading. Debug and trace APIs unlock at the Developer plan ($50/month) and above.

The gap for institutional teams is published compliance documentation. As of August 2026, Infura’s public site doesn’t document a SOC 2 or ISO 27001 certification the way Chainstack, Alchemy, or Quicknode do. For a compliance team assembling a vendor-attestation package, an unpublished certification status is treated the same as no certification — the review process needs audited, documented evidence, not a verbal assurance. The enterprise tier offers custom SLAs and priority support, but that gap remains until Infura publishes certification documentation.

Limitations: No published SOC 2 or equivalent certification — a real gap for institutional vendor assessment. No standard dedicated node offering. Compliance posture requires a direct sales inquiry rather than a citable public document.

Fit for institutional DeFi:

• Archive & trace: Strong — archive included on every plan, trace unlocks at the Developer tier
• Dedicated throughput: Limited — no standard dedicated option
• Compliance posture: Limited — no published SOC 2 or ISO 27001 as of this writing
• Uptime SLA: Good — enterprise tier offers custom SLAs; no contractual SLA on standard plans

Alchemy

Alchemy prices by Compute Unit, with archive, trace, and NFT-API methods weighted more heavily than a simple read — a debug_traceTransaction costs meaningfully more than eth_blockNumber, which complicates cost modeling for trace-heavy institutional workloads. The free tier is generous at 30M CU/month, and pay-as-you-go runs $0.45 per million CU up to 300M CU/month, then $0.40 per million beyond that. Alchemy publishes SOC 2 Type II certification; it does not publish an ISO 27001 certification, so teams that specifically require both should verify current status before assuming coverage.

Alchemy’s institutional appeal leans on its developer tooling: a Transfers API for account balance history, webhook infrastructure for event-driven architectures, and NFT and Token APIs. For institutional teams building monitoring dashboards rather than issuing raw RPC calls directly, those higher-level APIs can meaningfully cut engineering complexity, and Alchemy’s webhook infrastructure is a genuine fit for compliance event pipelines.

Alchemy offers no standard dedicated node option. Enterprise clients can request custom infrastructure, but outside that tier every request runs through shared infrastructure — there’s no isolation step between the developer plan and a custom enterprise engagement, which leaves mid-sized institutional deployments without a path to predictable latency short of that jump.

Limitations: No standard dedicated nodes below enterprise. CU cost for trace methods is high and variable, and for a team where debug_traceTransaction is a routine compliance workflow, the bill can surprise. Teams scaling past the free tier should model CU costs against actual method mix before committing to a volume.

Fit for institutional DeFi:

• Archive & trace: Good — available, though CU pricing on trace methods adds up quickly at scale
• Dedicated throughput: Limited — no standard dedicated option; shared infrastructure outside enterprise
• Compliance posture: Good — SOC 2 Type II published; ISO 27001 not published, verify if that specific certification is a hard requirement
• Uptime SLA: Good — strong observed availability, but a contractual SLA requires an enterprise engagement

Quicknode

Quicknode uses credit-based pricing weighted by method complexity, so a debug_traceTransaction call consumes a different number of credits than eth_blockNumber — a real complication for cost forecasting on compliance-heavy workloads. The free tier is a one-month trial with 10M credits, not a recurring plan, which means institutional teams can’t keep a Quicknode endpoint running for ongoing development and testing without moving to a paid tier. Paid plans run from Build ($49/month, 80M credits, 50 RPS) through Business ($999/month, 2B credits, 500 RPS), with several Business+ tiers above that for higher credit volumes.

For institutional deployments, the enterprise tier is the relevant one: dedicated clusters, SOC 2 Type II plus ISO 27001 certification, a documented uptime SLA, and RBAC/SSO for team access control. The dual certification is a genuinely stronger compliance story than SOC 2 alone, and can matter specifically for firms operating under ISO-aligned frameworks in Europe. Trace and debug methods unlock from the Build tier upward, and Ethereum archive access is available on paid plans. Quicknode’s credit-based pricing can surprise teams once archive or trace calls enter the mix in volume — worth modeling against your actual method mix before committing to a tier.

Limitations: Dedicated infrastructure is enterprise-only, so mid-market institutional teams on Scale or Business tiers remain on shared infrastructure. Method-weighted credit consumption makes billing harder to forecast for compliance-heavy workflows than flat per-call pricing. The one-month trial is short for a proper institutional evaluation cycle.

Fit for institutional DeFi:

• Archive & trace: Strong — available on paid plans, though credit cost per call varies by method
• Dedicated throughput: Moderate — isolated clusters are enterprise-only; Business tier is still shared
• Compliance posture: Strong — SOC 2 Type II and ISO 27001 on enterprise; not active on lower tiers
• Uptime SLA: Strong — documented SLA, contractual on enterprise

Real-world performance benchmark

Ethereum is tracked on the Chainstack performance dashboard, which provides live latency data across providers and regions for methods including eth_call, eth_getLogs, and eth_subscribe. For a quick top-level ranking, compare.chainstack.com is the faster read; the Grafana dashboard is the drill-down when a method-level breakdown matters, which for institutional trace and archive workloads it usually does.

The table below shows representative latency ranges pulled from the dashboard (check the live dashboard for current figures before any production decision):

Method	Chainstack (EU)	Quicknode (EU)	Alchemy (EU)
eth_call	~35–50 ms	~45–70 ms	~50–80 ms
eth_getLogs	~40–60 ms	~50–80 ms	~55–90 ms
eth_subscribe (new heads)	~20–35 ms	~30–55 ms	~35–60 ms

⚡ Check current figures: The dashboard updates continuously. Before finalizing a provider for a production institutional deployment, run your own latency test from your target region using the Chainstack performance dashboard as a baseline — for institutional deployments where p95 latency is itself a compliance-relevant metric, a reproducible, source-linked benchmark belongs in the vendor assessment file.

Getting started with Ethereum on Chainstack

Deploying a Chainstack Ethereum endpoint for institutional DeFi takes about five minutes.

1. Log in to the Chainstack console (or create an account).
2. Create a new project
3. Select Ethereum as your blockchain protocol
4. Choose network: Ethereum Mainnet or Sepolia / Hoodi testnet
5. Deploy the node
6. Open Access and credentials and copy your HTTPS and WebSocket endpoints

For institutional workloads, deploy in archive mode with the debug and trace namespaces enabled so compliance queries work without a later reconfiguration. For production use, evaluate Dedicated Nodes over Global Nodes once you’re past initial development — both are available inside the same project.

The example below connects to a Chainstack Ethereum endpoint and subscribes over WebSocket to Aave V3 LiquidationCall events in real time:

import asyncio
from web3 import Web3, AsyncWeb3

AAVE_V3_POOL = "YOUR_CONTRACT_ADDRESS"

async def stream_liquidations():
    """Subscribe to Aave V3 LiquidationCall events via WebSocket."""
    http_w3 = Web3(Web3.HTTPProvider("YOUR_CHAINSTACK_HTTP_ENDPOINT"))

    wss_w3 = await AsyncWeb3(AsyncWeb3.WebSocketProvider(
        "YOUR_CHAINSTACK_WSS_ENDPOINT"
    ))

    liquidation_topic = http_w3.keccak(
        text="LiquidationCall(address,address,address,uint256,uint256,address,bool)"
    ).hex()

    subscription_id = await wss_w3.eth.subscribe("logs", {
        "address": AAVE_V3_POOL,
        "topics": [liquidation_topic]
    })

    print(f"Subscribed to Aave liquidations: {subscription_id}")

    async for log in wss_w3.socket.process_subscriptions():
        print(f"Liquidation at block {log['result']['blockNumber']}")

asyncio.run(stream_liquidations())

See the Ethereum tooling documentation for complete SDK examples with ethers.js, viem, and Web3.py. Need testnet ETH? Grab some from the Chainstack Sepolia faucet.

🤖 You can also access Chainstack Ethereum RPC directly from Claude, 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 provider decision for institutional DeFi on Ethereum in 2026 comes down to one question: can the provider produce an audited compliance package and dedicated isolation that holds up under market stress, in one contract? Most providers can serve Ethereum RPC requests. Far fewer can pair archive and trace access with SOC 2 Type II and ISO 27001 evidence and a contractual uptime SLA.

• For institutional compliance requirements and production deployments: Chainstack — audited SOC 2 Type II and ISO 27001, Dedicated Nodes with archive and trace included, contractual SLA on Enterprise, flat RU pricing
• For teams that need multi-provider failover across many EVM chains at once: RouteMesh — automatic failover and sub-10ms routing decisions across upstream providers, including Chainstack
• For compliance event pipelines and webhook-driven monitoring: Uniblock — Unified APIs and webhooks pooled across 55+ underlying providers
• For custody-adjacent institutional relationships with Tier-1 banking clients already on the platform: Blockdaemon — audited SOC 2 Type II and ISO 27001, on-premise options, custom contractual terms
• For teams with established ConsenSys relationships and archive-on-every-plan requirements: Infura — but verify compliance certification status before use in a regulated context
• For developer-heavy teams comfortable with shared infrastructure: Alchemy — strong API ecosystem, generous free tier, published SOC 2 Type II
• For teams with existing Quicknode contracts or a hard ISO 27001 requirement: Quicknode enterprise — dual SOC 2 Type II and ISO 27001, dedicated clusters at the enterprise tier

Frequently asked questions

Q: Does eth_getLogs require an archive node on Ethereum?

No, not for recent block ranges — it works on a standard full node. Archive access is only required once the query range extends past the node’s retention window, roughly 127 blocks on a pruned full node. Historical state queries like eth_call, eth_getBalance, or eth_getStorageAt at a specific past blockNumber, and every debug_*/trace_* method, do require archive.

Q: Which Ethereum RPC providers offer a permanent free tier suitable for institutional evaluation?

Chainstack (3M RU/month), Alchemy (30M CU/month), and Infura (3M credits/day) all run permanent free plans with no time limit. Quicknode’s free offering is explicitly a one-month trial with 10M credits, not a recurring tier, which matters if your evaluation cycle runs longer than a month.

Q: How do I migrate an institutional Ethereum monitoring stack from another provider to Chainstack without downtime?

Deploy the new Chainstack endpoint alongside the existing one and run both in parallel for a full monitoring cycle — including a liquidation event or volatility spike, if your evaluation window allows it — before cutting traffic over. Confirm archive depth, debug/trace namespace availability, and WebSocket subscription behavior match on both endpoints first, since these are the details that silently differ between providers.

Q: What RPC latency should institutional DeFi teams target on Ethereum?

Sub-100ms is a reasonable target for the endpoint itself, but p95 and p99 matter more than the average — a provider that’s fast most of the time and slow during volatility is the one that costs you the liquidation window. Check the Chainstack performance dashboard or compare.chainstack.com for current cross-provider figures, and run your own regional test before committing to production.

Q: Which Ethereum RPC providers hold SOC 2 Type II and ISO 27001 certification?

Chainstack holds an audited SOC 2 Type II and ISO 27001 certification. Blockdaemon and Quicknode (on its enterprise tier) also publish both certifications, through their own audits. Alchemy publishes SOC 2 Type II but not ISO 27001. Infura does not publicly document either certification as of this writing. RouteMesh and Uniblock, as routing layers, don’t publish their own certification independent of the upstream providers they route to.

Q: How does Ethereum RPC pricing differ between flat and method-weighted providers?

Chainstack bills every call at 1 Request Unit, with archive/debug/trace calls at 2 RU — a flat multiplier, not a per-method one. Alchemy and Quicknode weight pricing by method complexity, so debug_traceTransaction or trace_block can cost 20–26× a simple read on some published comparisons. For a workload heavy in archive or trace calls, the sticker price isn’t the real price — see the interactive cost calculator to model your own method mix before committing to a tier.

Additional resources

• How to get an Ethereum RPC endpoint in 2026
• Ethereum tooling documentation — Chainstack Docs
• Ethereum methods reference — Chainstack Docs
• Ethereum API reference overview — Chainstack Docs
• More Ethereum tutorials and articles on the Chainstack blog
• Chainstack archive data
• Chainstack pricing
• Chainstack performance dashboard