Ethereum RPC for institutional DeFi: best providers and infrastructure guide 2026

Ethereum RPC infrastructure underpins the world’s largest DeFi ecosystem — over $50 billion in total value locked across protocols including Aave, Uniswap, Curve, and Morpho. The institutional inflection point arrived in 2025–2026 when BlackRock’s BUIDL fund crossed $2.9 billion in on-chain assets, Securitize built regulated tokenization infrastructure 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 protocols.

For institutional teams — asset managers monitoring collateral positions in real time, compliance officers reconstructing execution traces for regulators, or protocol treasuries operating 24/7 settlement infrastructure — RPC provider selection now carries the same due diligence weight as choosing a prime broker. Shared endpoints with opaque rate limiting, no contractual uptime guarantees, and uncertified security posture fail the vendor assessment that most compliance and legal teams now require.

This guide covers the five providers best positioned for institutional DeFi on Ethereum, from the exact RPC methods this workload demands to the dedicated infrastructure and compliance certifications that separate production-grade from adequate.

💡 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 is not high-frequency trading — Aave collateral monitoring on 12-second block intervals tolerates response latencies that would destroy an MEV bot. But it is not batch analytics either. Liquidation monitoring, position health alerts, and real-time settlement confirmation all require consistent sub-100ms endpoint latency. The more important figure is p95, not average: a provider that delivers 40ms average but 2,000ms at the 95th percentile will miss liquidation windows during the exact market conditions when positions go underwater.

During volatility events — a large collateral ratio breach triggering a cascade of Aave liquidations, or a Curve pool depeg — transaction volume on Ethereum spikes sharply. Endpoints that degrade gracefully under that load are a distinguishing feature, not a given.

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 state 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 require the most throughput.

Key RPC methods

The seven methods that define the institutional DeFi workload 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. Does not require archive for queries against "latest" — requires archive only when querying a historical blockNumber.
• eth_getLogs — Returns emitted events matching a filter: deposits, withdrawals, liquidations, transfers. Does not require an archive node when scanning recent block ranges; it works on a standard full node. Archive is only needed when scanning ranges extending back beyond the node’s state retention window (typically 128 blocks for pruned full nodes, or 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: an institution needs confirmation that a deposit or withdrawal executed, along with the log events proving it.
• eth_subscribe — WebSocket-only method for real-time subscriptions: new block headers, pending transactions, or log events matching a filter. Any latency-sensitive institutional process — liquidation monitoring, oracle price tracking — must use eth_subscribe rather than 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 archive + debug-enabled node. The compliance team’s primary method: reconstructing exactly what happened in a transaction for regulatory reporting, incident response, or audit.
• trace_transaction / trace_block — Parity-style trace methods returning internal call structure and value transfers, including calls that don’t appear in logs. Require archive + trace-enabled node. Used by analytics pipelines and compliance teams that need a structured account of internal transfers the standard receipt omits.
• eth_getBalance / eth_getStorageAt at a historical blockNumber — Historical state queries for reconciliation: “what was this address’s balance at block 19,000,000?” or “what was this storage slot’s value at a specific point in time?” Require archive access. These are the methods driving demand for archive endpoints in institutional deployments — not eth_getLogs, which works on full nodes.

Infrastructure requirements

Institutional deployments belong on Dedicated Nodes, not shared pools. The fundamental issue is resource contention: a shared endpoint serves thousands of concurrent projects, meaning your p95 latency during a major DeFi event reflects the aggregate load of everyone on the platform. Dedicated Nodes provide a predictable, isolated capacity ceiling and consistent latency independent of other tenants.

Geographic proximity matters for latency-sensitive operations. Running a liquidation bot colocated with your node in the same AWS us-east-1 or eu-west-1 datacenter reduces round-trip latency by tens of milliseconds compared to cross-region calls — a meaningful advantage on block timescales.

WebSocket endpoint availability is a non-negotiable for eth_subscribe. Not all providers expose WebSocket endpoints on all plans; confirm availability before committing to a provider for any event-driven architecture.

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

Chainstack for institutional DeFi on Ethereum

Chainstack’s enterprise stack is built around the compliance requirements that institutional DeFi teams face in 2026. The platform holds SOC 2 Type II certification — covering security, availability, and confidentiality over a sustained audit period — which satisfies the vendor attestation requirements of compliance teams operating under MiCA or GENIUS Act frameworks. SOC 2 Type II is an audited, time-period assessment; it is not a self-reported questionnaire or a point-in-time snapshot.

The relevant Chainstack product stack for institutional DeFi:

Dedicated Nodes — Isolated infrastructure on AWS, Azure, GCP, or Virtuozzo. Ethereum Dedicated Nodes include archive and trace support, meaning debug_traceTransaction, trace_block, trace_transaction, and all historical state queries work without additional configuration. Starting at $0.50/hour for compute. Dedicated Nodes with Bolt fast-sync technology minimize initial sync time when deploying new nodes.

Global Nodes — Geo-load-balanced shared endpoints across 12+ regions. Global Nodes include archive access at 2 RU per request. Appropriate for development, testing, and moderate-traffic use cases where dedicated isolation isn’t operationally required.

Unlimited Node add-on — Flat-rate throughput tiers from 25 to 500 RPS, starting at $149/month. Eliminates per-request billing and overage surprises. The Unlimited Node add-on works with Dedicated Nodes to give institutional teams a single predictable infrastructure line item — which matters significantly when procurement and finance teams review vendor contracts.

Enterprise tier — Available at chainstack.com/enterprise: contractual 1-hour response SLA, dedicated account team, custom throughput, and invoice-based billing. This tier also unlocks priority support during incidents, which for institutional teams managing live capital positions is the difference between a manageable event and a regulatory notification.

Chainstack also supports stablecoin and settlement infrastructure. If your institutional DeFi stack involves stablecoin issuance, redemption rails, or treasury settlement, see the stablecoin infrastructure page for compliance-focused deployment options.

The code below shows a minimal institutional monitoring pattern: fetching position health factors from Aave V3 and scanning for liquidation events, both critical for any institutional deployment managing capital on Ethereum.

from web3 import Web3

# Connect to Chainstack Ethereum dedicated node
w3 = Web3(Web3.HTTPProvider("https://YOUR-CHAINSTACK-ENDPOINT"))

# Aave V3 Pool contract on Ethereum mainnet
AAVE_V3_POOL = "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2"

# ABI fragment for getUserAccountData
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)

# Check health factor for a monitored address
def check_health_factor(address: str) -> float:
    data = pool.functions.getUserAccountData(address).call()
    health_factor = data[5] / 1e18  # Aave returns health factor as 18-decimal fixed point
    return health_factor

# Scan for LiquidationCall events in recent blocks
LIQUIDATION_TOPIC = w3.keccak(
    text="LiquidationCall(address,address,address,uint256,uint256,address,bool)"
).hex()

latest = w3.eth.block_number
logs = w3.eth.get_logs({
    "fromBlock": latest - 50,
    "toBlock": latest,
    "address": AAVE_V3_POOL,
    "topics": [LIQUIDATION_TOPIC]
})

print(f"Liquidation events in last 50 blocks: {len(logs)}")

See the Ethereum tooling documentation for SDK setup guides covering ethers.js, viem, and Web3.py.

🤖 You can also access Chainstack Ethereum RPC directly from Claude, Cursor, Codex, Gemini, or Windsurf using Chainstack MCP. Learn more about Chainstack MCP.

Provider comparison for institutional DeFi

The table below summarizes public positioning as of May 2026.

Provider	Pricing model	Free tier	Dedicated nodes	Archive & trace	Compliance
Chainstack	RU-based	3M RU/mo, 25 RPS	Yes, from $0.50/hr	Yes, included	SOC 2 Type II
Quicknode	Credit-based	10M credits (trial only)	Yes (enterprise)	Yes (paid plans)	SOC 2 Type II + ISO 27001 (enterprise)
Alchemy	CU-based	30M CU/mo	No	Yes	SOC 2 Type II
Infura	Credit-based	3M credits/day	No	Yes (Developer plan+)	Not published
GetBlock	CU-based	50K CU/mo	Yes, from $1,000/mo	Yes	Not published

Chainstack

Chainstack operates on a Request Unit model where full node requests consume 1 RU and archive requests consume 2 RU. There are no per-method price multipliers — a debug_traceTransaction call costs the same billing unit as an eth_blockNumber call, which makes cost modeling straightforward for institutional finance teams that need predictable infrastructure spend. Plans run from the free Developer tier (3M RU/month, 25 RPS) through Business ($499/month, 200M RU, 600 RPS) to Enterprise (from $990/month, 400M+ RU, contractual SLA).

Ethereum Dedicated Nodes on Chainstack include archive and the full debug and trace namespaces. A dedicated archive node is the foundation of institutional DeFi infrastructure: it supports debug_traceTransaction for compliance audit, trace_block for internal call analysis, and historical state queries at any block depth. The Unlimited Node add-on adds flat-rate RPS tiers ($149/month from 25 RPS) for teams that want to decouple infrastructure cost from request volume entirely.

The SOC 2 Type II certification covers security, availability, and confidentiality controls over a sustained period — not a point-in-time audit. For compliance teams preparing vendor attestation packages for regulators, this is the audit standard that actually satisfies review. The Enterprise tier adds a contractual 1-hour response SLA and a dedicated account team, which for live capital deployments means escalation paths exist before an incident becomes a regulatory event.

Limitations: The free tier’s 25 RPS ceiling is low for institutional testing; teams building out monitoring infrastructure will reach it quickly during load tests. Archive storage pricing ($0.01/20 GB-hour) adds to dedicated node costs for long-running deployments and should be modeled before committing.

Fit for institutional DeFi:

• Archive & trace: Excellent — included on all Dedicated Nodes, no extra configuration required
• Dedicated throughput: Excellent — isolated Dedicated Nodes with predictable capacity from $0.50/hour
• Compliance posture: Excellent — SOC 2 Type II certified, contractual SLA on enterprise tier
• Uptime SLA: Excellent — 99.99%+ uptime, contractual on enterprise

Quicknode

Quicknode uses a credit-based pricing model where requests are weighted by method complexity. The free tier is a 30-day trial with 10M credits — not a recurring free plan — which means institutional teams cannot maintain a Quicknode endpoint for development and testing without a paid subscription. Paid plans run from Build ($49/month, 80M credits, 50 RPS) through Business ($999/month, 2B credits, 500 RPS). Credits consumed by trace and debug methods vary in weight, so the cost per debug_traceTransaction call differs from a simple eth_blockNumber, complicating cost modeling.

For institutional deployments, the critical Quicknode feature is the enterprise tier: dedicated clusters, SOC 2 Type II plus ISO 27001 certification, 99.99% SLA, and RBAC/SSO for team access controls. The dual compliance certification (SOC 2 + ISO 27001) is a stronger compliance story than SOC 2 alone and may satisfy certain institutional requirements — particularly for firms operating under ISO-aligned frameworks in Europe. Trace and debug methods unlock at the Build tier and above. Ethereum archive access is available on paid plans.

Limitations: Dedicated nodes are enterprise-only, which means mid-market institutional teams on the Scale or Business tier are still on shared infrastructure. The credit weighting for expensive methods (trace, debug) creates unpredictable billing for compliance-heavy workflows. The 30-day trial is too short for a proper institutional evaluation cycle.

Fit for institutional DeFi:

• Archive & trace: Strong — available on paid plans, but 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 + ISO 27001 on enterprise; certifications not active on lower tiers
• Uptime SLA: Strong — 99.99% SLA documented, contractual on enterprise

Alchemy

Alchemy uses Compute Unit pricing where each method has a weighted CU cost — a debug_traceTransaction or trace_block call costs significantly more than a simple read, making Alchemy’s pricing less predictable for trace-heavy institutional workloads. The free tier is generous (30M CU/month, 25 RPS), which makes Alchemy practical for extended development and testing. Pay-as-you-go starts at $0.40/million CU. SOC 2 Type II is documented.

Alchemy’s institutional appeal comes partly from its developer tooling ecosystem: the Transfers API (for account balance history), Webhook infrastructure (for event-driven architectures), and the NFT and Token APIs. For institutional teams building Ethereum monitoring dashboards rather than running raw RPC calls, Alchemy’s higher-level APIs can reduce engineering complexity. The Trade API and Alchemy Notify webhooks are genuinely useful for compliance event pipelines.

However, Alchemy offers no standard dedicated node option. Enterprise clients can request custom infrastructure, but outside the enterprise tier, all requests route through shared infrastructure. This is the critical gap for institutional DeFi teams: there is no isolation tier between developer and enterprise, which means mid-sized deployments have no path to predictable latency without jumping to custom enterprise pricing.

Limitations: No standard dedicated nodes below enterprise. CU cost for trace methods is high and variable. For institutional teams where debug_traceTransaction is a regular compliance workflow, the cost per call can surprise.

Fit for institutional DeFi:

• Archive & trace: Good — available, but CU pricing for trace methods adds up quickly at scale
• Dedicated throughput: Limited — no standard dedicated option; shared infra only outside enterprise
• Compliance posture: Good — SOC 2 Type II certified; dedicated node SLA not contractual outside enterprise
• Uptime SLA: Good — strong availability, but contractual SLA requires enterprise engagement

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 (not per month), which is a meaningful recurring allowance for evaluation and development use. All plans include full archive access, which is noteworthy — on Infura, a developer plan account can execute eth_getBalance at a historical block without upgrading. Debug and trace APIs unlock at the Developer plan ($50/month) and above.

For institutional teams evaluating Infura, the primary concern is the absence of published compliance certifications. SOC 2 status is not documented publicly on Infura’s pricing or security pages as of May 2026. For compliance teams preparing vendor due diligence packages, “not published” is effectively the same as “not available” — the institutional review process requires documented, audited evidence. The enterprise tier offers custom SLAs and priority support, but the compliance gap remains until Infura publishes certification documentation.

Credit pricing uses a computational complexity model similar to Quicknode. debug_traceTransaction and trace methods cost more credits than standard reads, though Infura’s pricing page describes this in general terms rather than publishing a specific per-method cost table.

Limitations: No published SOC 2 certification — a significant gap for institutional vendor assessment. No standard dedicated node offering. Compliance posture requires direct inquiry rather than referencing published documentation.

Fit for institutional DeFi:

• Archive & trace: Strong — archive included on all plans, trace unlocks at Developer tier
• Dedicated throughput: Limited — no standard dedicated option
• Compliance posture: Limited — no published SOC 2 or equivalent certification as of May 2026
• Uptime SLA: Good — enterprise tier offers custom SLAs; no contractual SLA on standard plans

GetBlock

GetBlock is a CU-based provider with dedicated node options, Ethereum archive access, and an enterprise tier. The free tier offers 50K CU/month — low for evaluation purposes, but dedicated nodes start at $1,000/month with unlimited requests and no rate limits. For teams where the primary requirement is dedicated isolation on a fixed budget, GetBlock’s dedicated node pricing provides a clear option. The platform supports JSON-RPC, GraphQL, and WebSocket interfaces on Ethereum, and archive data is available for historical state queries and trace methods.

The institutional gap is compliance documentation. GetBlock does not publish SOC 2 or equivalent certification as of May 2026. The enterprise tier offers 24/7 support and custom configurations, but vendor attestation for regulatory review requires audited evidence, and the absence of published compliance certifications limits GetBlock’s viability for institutional teams operating under formal compliance programs.

GetBlock’s pricing transparency is partial: the CU cost per method is not published in a publicly accessible table, which creates similar cost modeling challenges as other CU-based providers when trace or debug methods constitute a significant portion of the request mix.

Limitations: No published compliance certifications. Free tier is minimal (50K CU). CU cost structure for trace/debug methods not publicly detailed. Less ecosystem depth than Chainstack, Alchemy, or Quicknode for developer tooling.

Fit for institutional DeFi:

• Archive & trace: Good — archive available, trace supported; dedicated nodes unlock unlimited usage
• Dedicated throughput: Good — dedicated nodes available from $1,000/month with no rate limits
• Compliance posture: Limited — no published SOC 2 or ISO certification
• Uptime SLA: Moderate — enterprise tier support documented; no published contractual uptime SLA

Real-world performance benchmark

Ethereum is tracked on the Chainstack performance dashboard, which provides live latency data across providers and regions for key methods including eth_call, eth_getLogs, and eth_subscribe. The dashboard is updated continuously and shows method-level response times across EU, US West, and APAC regions.

The table below shows representative latency ranges from the dashboard across providers (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

Data sourced from the Chainstack performance dashboard. For institutional deployments where p95 latency is a compliance-relevant metric, the dashboard provides a reproducible, source-linked benchmark suitable for vendor assessment documentation.

⚡ Check current figures: The dashboard updates in real time. Before finalizing provider selection for a production institutional deployment, run your own latency test from your target region using the Chainstack performance dashboard as a baseline.

Getting started with Ethereum on Chainstack

Deploying a Chainstack Ethereum endpoint for institutional DeFi takes under five minutes:

1. Create an account at Chainstack or log in to your existing account.
2. Create a project — projects group your nodes and manage access controls.
3. Deploy an Ethereum Mainnet node — select archive mode and enable the debug and trace namespaces for compliance workloads.
4. Choose your node type — Dedicated Nodes for production institutional use; Global Nodes for development.
5. Copy your HTTPS and WSS endpoints — HTTPS for request/response calls, WebSocket for eth_subscribe event streaming.

The example below connects to a Chainstack Ethereum endpoint, checks a position health factor on Aave V3, and subscribes via WebSocket to receive real-time LiquidationCall events:

import asyncio
from web3 import Web3, AsyncWeb3

# HTTP endpoint — for eth_call, eth_getLogs, eth_getTransactionReceipt
http_w3 = Web3(Web3.HTTPProvider("https://YOUR-CHAINSTACK-HTTP-ENDPOINT"))

# Health factor check (requires Aave V3 Pool ABI — abbreviated here)
AAVE_V3_POOL = "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2"

async def stream_liquidations():
    """Subscribe to Aave V3 LiquidationCall events via WebSocket."""
    wss_w3 = await AsyncWeb3(AsyncWeb3.WebSocketProvider(
        "wss://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']}: "
              f"collateral {log['result']['topics'][1]}")

asyncio.run(stream_liquidations())

See the Ethereum tooling documentation for complete SDK examples with ethers.js, viem, and Foundry integration.

🤖 You can also access Chainstack Ethereum RPC directly from Claude, Cursor, Codex, Gemini, or Windsurf using Chainstack MCP. Learn more about Chainstack MCP.

Conclusion

The provider choice for institutional DeFi on Ethereum in 2026 comes down to a single question: can the provider produce an audited compliance package, and does it offer dedicated isolation that holds up under market stress? Most providers can serve Ethereum RPC requests. Far fewer can provide SOC 2 Type II evidence, contractual uptime SLAs, and dedicated archive nodes — all in one invoice.

• For institutional compliance requirements and production DeFi deployments: Chainstack — SOC 2 Type II certified, Dedicated Nodes with archive and trace included, contractual SLA on enterprise, transparent RU pricing
• For institutional teams with existing Quicknode contracts or ISO 27001 requirements: Quicknode enterprise — dual SOC 2 + ISO 27001 certification, dedicated clusters on enterprise tier
• For developer-heavy teams that prioritize tooling and are comfortable with shared infra: Alchemy — SOC 2 Type II, strong API ecosystem, generous free tier for development
• For teams with established ConsenSys relationships and archive-on-all-plans requirements: Infura — archive on every tier, ConsenSys/MetaMask Developer backing, but verify compliance certification status before use in a regulated context
• For cost-focused deployments that need dedicated isolation without enterprise pricing: GetBlock — dedicated nodes from $1,000/month, but obtain compliance documentation directly before vendor assessment

Additional resources

• How to get an Ethereum RPC endpoint in 2026
• Ethereum tooling documentation — Chainstack Docs
• Ethereum methods reference — Chainstack Docs
• More Ethereum tutorials and articles on the Chainstack Blog
• Tutorials and guides for Ethereum on Chainstack
• Chainstack pricing
• Chainstack performance dashboard