Top 7 Ethereum RPC providers for custodians and asset managers in 2026

Ethereum is the settlement layer institutional custody platforms build against — the chain where tokenized real-world assets, stablecoin reserves, and regulated fund positions actually settle. On March 17, 2026, the SEC and CFTC jointly classified ETH as a digital commodity under federal guidance, closing more than a decade of security-versus-commodity ambiguity and setting the compliance baseline that qualified custodians and asset managers now design infrastructure around.

The network backs that role at scale: Ethereum settles roughly 2.6 million transactions a day as of August 2026, and secures $41.8 billion in DeFi TVL — an increasing share of it custodied on behalf of institutions rather than held in retail wallets. The compliance clock is running in parallel: the EU’s MiCA regime and the US GENIUS Act both push custodians toward auditable, SLA-backed infrastructure instead of best-effort public endpoints, a shift covered in Chainstack’s 2026 crypto regulation guide.

This guide compares seven Ethereum RPC providers specifically through the lens of custody and asset management: archive depth, audit-trail methods, published compliance certifications, and the throughput and support commitments that regulated infrastructure teams actually sign off on.

💡 Already using Chainstack? Jump straight to the Ethereum tooling docs or deploy your endpoint in minutes at chainstack.com/build-better-with-ethereum.

Custodians and asset managers on Ethereum: RPC requirements

Custody infrastructure is not latency-critical the way trading bots are — a settlement confirmation taking 200ms instead of 50ms rarely matters. What matters is correctness, completeness, and auditability at scale. A missed eth_getLogs event is a reconciliation gap. A failed debug_traceTransaction call is an incomplete audit record. A provider outage during a regulatory reporting window is a compliance event, not a technical inconvenience.

Latency and throughput profile

Custody platforms typically run two concurrent workload patterns:

• High-frequency polling — monitoring hundreds or thousands of wallet addresses for incoming transfers using eth_getLogs on short block ranges every few seconds. This is sustained, moderate-RPS load (roughly 50–200 RPS) that runs continuously.
• On-demand audit calls — triggered by compliance requests, fund NAV calculations, or incident response. These are bursty, latency-tolerant calls that must succeed on the first attempt. debug_traceTransaction against an archive node is the canonical example.

The combination demands a provider with consistent throughput under sustained load and archive plus debug access that does not degrade under concurrent requests. A shared endpoint with aggressive method-level rate limits fails the second pattern at exactly the wrong moment — during an audit request.

Key RPC methods for custody and asset management

• eth_getLogs — the reconciliation workhorse. Custody platforms use it to index ERC-20 Transfer events across client wallets and rebuild an audit log of every inbound and outbound flow. Ethereum’s recommended block range per call is capped by most providers; full historical reconciliation means calling it iteratively across the whole range, which requires a provider with no aggressive block-range caps and reliable response times at volume. eth_getLogs does not require an archive node for recent blocks — a full node serves event log scans on the last ~128 blocks of state, and log queries further back still work without full historical state access.
• eth_getTransactionReceipt — settlement confirmation. This determines whether a transaction actually succeeded (status: 1) and, critically, what events it emitted via the logs array. Custody workflows call this on every outbound transaction and every incoming transfer flagged by eth_getLogs. It must return reliably with complete log data — truncation breaks downstream reconciliation.
• eth_getTransactionByHash — audit record retrieval. Regulators and internal auditors routinely request full transaction detail: sender, receiver, value, input data, gas parameters. For transactions older than a full node’s retention window, this requires archive access.
• debug_traceTransaction — the compliance trace. This returns the complete EVM execution trace of a transaction: every opcode, every storage read and write, every internal call. It’s mandatory for fund-flow analysis (multi-hop DeFi interactions), incident investigation, and regulatory audit requests. This method requires an archive node and is frequently disabled or rate-limited on shared endpoints because of its computational cost. For custody platforms building on RPC infrastructure for tokenized asset protocols, this is the method regulators tend to ask for first.
• trace_transaction — the Erigon-namespace alternative. It returns structured internal-transaction traces (call traces, value transfers) without the opcode-level detail of debug_traceTransaction, which is often easier to parse for fund-flow analysis. Also requires archive access.
• eth_getBalance — balance verification. Called on segregated client wallets for daily NAV calculations and proof-of-reserves attestations. Historical balance queries at a past block — for point-in-time NAV or audit reconstruction — require an archive node.
• eth_blockNumber — chain-tip synchronization. Used to confirm the provider’s node is in sync before running reconciliation; a stale block height means stale data, a critical failure for settlement workflows.
• eth_subscribe (logs) — WebSocket event streaming. Production custody platforms subscribe rather than poll for real-time settlement detection, filtering on specific contract addresses (stablecoin contracts, custody registries) for sub-block-latency delivery. Reconnect handling matters here — a dropped subscription means missed events.

For the full execution and consensus-layer method surface, including the debug_*, trace_*, and erigon_* namespaces referenced above, see the Ethereum API reference.

Infrastructure requirements

Archive node access is non-negotiable for any custody platform that serves historical data requests, responds to regulatory inquiries, or runs historical NAV calculations. debug_traceTransaction, trace_transaction, and historical state queries (eth_getBalance at a past block) all require it — see Chainstack’s archive data page for what full historical-state access looks like in practice. A full node keeps roughly the latest 128 blocks of state; anything older needs archive. Providers that offer archive as a capped or paid add-on with limited historical depth need to be evaluated on that depth specifically, not just “archive: yes/no.” One nuance worth knowing: pre-built native tracers (callTracer, prestateTracer) work against a standard archive node, but custom JavaScript tracers require a Dedicated Node rather than a shared archive endpoint.

Dedicated Nodes versus shared endpoints becomes relevant above roughly 100 RPS sustained, or whenever concurrent debug_traceTransaction calls need to run without competing for a shared rate-limit budget. Shared endpoints with method-level throttling can rate-limit trace calls under load — at precisely the moment a compliance team needs them.

MEV protection is a real, if underappreciated, custody concern on Ethereum — large custodial rebalancing transactions and client withdrawals sent through a public mempool are visible to searchers before they land, creating front-running and sandwich-attack exposure. A provider that routes transactions through a private order flow by default, rather than as an opt-in step a compliance-constrained team has to remember to configure, meaningfully reduces that exposure.

Geographic redundancy and SLA matter for regulated entities. A 99.9% SLA (roughly 8.7 hours of downtime per year) is thin for infrastructure supporting live fund operations. Providers publishing a 99.99%+ SLA with contractual remedies are the more defensible choice for institutional deployment.

SOC 2 Type II and ISO 27001 certification are now the baseline for institutional vendor onboarding — banks and fund administrators require them as standard procurement criteria. A self-reported “SOC 2 in progress” claim is not equivalent to a completed Type II audit with a published report, and the two certifications cover different things: SOC 2 Type II evidences operating effectiveness over a review period, ISO 27001 evidences a certified information security management system. A provider holding one is not automatically holding the other, so check both explicitly rather than treating them as a single checkbox.

Provider comparison

The table below summarizes public positioning as of August 2026. To keep the comparison focused on custody and asset-management fit, it narrows to providers with either institutional-grade credentials or genuine product differentiation for this workload — general-purpose providers without a published compliance certification (Infura, GetBlock, dRPC) are not included here, though they remain reasonable choices for non-regulated Ethereum workloads.

Provider	Pricing model	Archive, debug & trace	Compliance certifications	Dedicated infrastructure	Why it matters for custodians & asset managers
Chainstack	Flat RU (1 full, 2 archive/debug/trace)	Full archive + debug + trace (Growth plan+)	SOC 2 Type II (Dec 2025) + ISO 27001 (Jul 2026)	Yes (Pro plan+)	Predictable audit-workload cost, both certifications published, MEV protection on by default
RouteMesh	Per-request routing fee	Inherits from upstream provider	Not independently published	Not applicable (routing layer)	Multi-provider failover for continuous wallet-monitoring uptime
Uniblock	Per-request across 55+ providers	Inherits from upstream provider	Not independently published	Not applicable (routing layer)	Pooled rate-limit headroom plus unified token/portfolio APIs
Blockdaemon	Custom, institutional	Available (custom scoping)	SOC 2 Type II + ISO 27001	Yes	Built specifically for banks and custodians; staking and custody bundled
Ankr	API credits	Archive on paid plans	SOC 2 Type II only	Available (Premium+)	Largest free evaluation runway; ISO 27001 not yet completed
Alchemy	Method-weighted CU	Archive + debug on paid plans	SOC 2 Type II only	No standard dedicated tier	Strong tooling, but no ISO 27001 blocks some dual-certification mandates
Quicknode	Method-weighted credits	Archive on all paid plans	SOC 2 Type II + ISO 27001	Enterprise only	Dual-certified, but pricier at scale for trace-heavy audit workloads

⚠️ Note on compliance certifications: Only published, independently audited SOC 2 Type II and ISO 27001 reports are listed as held. Self-reported “in progress” status and undocumented assertions are not counted as certified.

Chainstack

Custody workloads live or die on archive depth and cost predictability under audit-heavy trace usage. Chainstack maps onto both directly: every plan from Growth up includes full Ethereum archive access, with debug_traceTransaction, trace_transaction, and the full erigon_* namespace available on archive-enabled endpoints without extra method-level throttling beyond the plan’s RPS ceiling.

The pricing model is the most transparent in this comparison: a full node call costs 1 request unit (RU), and any call touching state 128+ blocks behind the tip — or any debug_*/trace_* call regardless of block age — costs 2 RU, flat. A debug_traceTransaction call costs the same as any other archive read in RU terms, which is what makes cost forecasting realistic for a compliance team budgeting an audit-heavy quarter. Plans run from the free Developer tier (3M RU/month, 25 RPS, full node only, no card required) through Growth ($49/month, 20M RU, 250 RPS, archive and debug/trace unlocked), Pro ($199/month, 80M RU, 400 RPS, Dedicated Nodes and SSO unlocked), and Business ($499/month, 200M RU, 600 RPS, role-based access control), with custom Enterprise contracts for larger volumes and contractual SLA terms.

For regulated workflows, Chainstack holds both SOC 2 Type II (completed December 22, 2025) and ISO 27001 (achieved July 2026) — the dual-certification pairing that vendor risk teams increasingly treat as table stakes. Global Nodes run geo-load-balanced across Chainstack’s Asia-Pacific, Europe, and US regions with a published 99.99%+ uptime target, and MEV protection is switched on by default at node deployment for Ethereum mainnet — not an opt-in step — free on every plan including the Developer tier, and can be turned off from the node’s Add-ons tab for workflows that specifically need public-mempool behavior. The Enterprise plan adds SSO, granular role-based permissions, a dedicated account team, and a custom uptime SLA with service credits — the package vendor risk reviews expect to see. Support scales with plan tier too: Developer and Growth get community and standard email support, while the Professional and Premium support add-ons commit to under-6-hour and under-1-hour response times respectively, with the Enterprise plan’s dedicated account team providing 24/7 coverage.

Dedicated Nodes isolate a custody workload from shared infrastructure — useful for platforms running continuous high-volume eth_getLogs polling alongside on-demand trace calls that would otherwise compete for the same rate-limit budget. For predictable-throughput monitoring pipelines, the Unlimited Node add-on (from $149/month for a 25 RPS tier, available from Growth up) bills a flat monthly rate instead of per-request, which removes the RU-forecasting exercise entirely for that workload.

The following snippet reconciles ERC-20 Transfer events into a monitored set of custody wallets over the last 500 blocks, using ethers.js in the style shown in the Ethereum tooling documentation:

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("YOUR_CHAINSTACK_ENDPOINT");

// ERC-20 Transfer event topic
const TRANSFER_TOPIC = ethers.id("Transfer(address,address,uint256)");

// Custody wallet addresses (padded to 32 bytes for topic filter)
const wallets = [
  "YOUR_CUSTODY_WALLET_1",
  "YOUR_CUSTODY_WALLET_2",
].map((addr) => ethers.zeroPadValue(addr, 32));

async function reconcile() {
  const latestBlock = await provider.getBlockNumber();
  const fromBlock = latestBlock - 500;

  const logs = await provider.getLogs({
    fromBlock,
    toBlock: latestBlock,
    topics: [TRANSFER_TOPIC, null, wallets],
  });

  for (const log of logs) {
    const amount = ethers.toBigInt(log.data);
    console.log(
      `Inbound transfer: ${log.transactionHash} | block ${log.blockNumber} | amount ${ethers.formatUnits(amount, 18)}`
    );
  }
}

reconcile();

Limitations: The Unlimited Node add-on’s flat RPS tiers can cost more than per-request billing for workloads with genuinely variable traffic that only occasionally spikes above the chosen tier. Very large one-off archive backfills are worth a sizing conversation with the Chainstack team rather than assuming a shared endpoint handles them unthrottled.

Fit for custodians and asset managers: Excellent — full archive and debug/trace from the Growth plan, both certifications published, flat-rate cost model, MEV protection on by default, and an Enterprise tier built around SSO, RBAC, and contractual SLA.

RouteMesh

RouteMesh is an intelligent RPC routing layer spanning 1,000+ EVM networks, including Ethereum mainnet and Sepolia. It aggregates and routes across multiple underlying providers with sub-10ms routing decisions, real-time health scoring, and automatic failover — a different product shape from a direct node connection, closer to a reliability layer sitting in front of several backends at once.

Reference customers include LI.FI (60+ chains, 97% of its EVM RPC calls routed through RouteMesh), Vaults.fyi, and DAMM Capital — the latter a genuinely relevant reference point for asset-management buyers evaluating failover behavior under real fund-operations load. Pricing is per-request, varying by key type, chain, and method; an MCP server and Cursor integration are available for teams wiring routing decisions into agentic workflows.

Limitations: RouteMesh does not itself publish a SOC 2 or ISO 27001 report — its own security posture is a separate due-diligence item from whichever backend node operator ultimately serves a given request. Archive and debug/trace depth depend entirely on which upstream provider a request lands on, which makes it harder to give a single, consistent audit-workflow answer.

Fit for custodians and asset managers: Good for the specific job of failover — a custody platform running continuous wallet-monitoring benefits from automatic rerouting around a degraded backend, though it is a complement to a certified primary provider rather than a substitute for one.

Uniblock

Uniblock is a managed multi-chain infrastructure layer covering 300+ blockchains, including Ethereum, through 55+ underlying RPC providers with automatic routing, failover, and hedging. Beyond raw JSON-RPC, it exposes Unified APIs for token, NFT, and market data — useful for a custody or asset-management dashboard that needs enriched position data alongside settlement confirmation, without hand-rolling multiple integrations.

Customers include Plume Network, Stellar, Hypernative, and Oku Trade, across a reported 4,000+ developers and 3,000+ projects; the company raised $5.2M in March 2026. An MCP server and agent skills for Cursor and GitHub Copilot are available for teams building agentic tooling on top of the API layer.

Limitations: As with RouteMesh, Uniblock does not independently publish SOC 2 or ISO 27001 certification, and archive/debug availability is a function of whichever of its 55+ backend providers serves a given call — not a fixed, auditable guarantee a compliance team can cite on its own.

Fit for custodians and asset managers: Good where the enriched Unified APIs genuinely save integration work — a portfolio-reporting layer built on top of raw settlement data is a real fit; treat the underlying RPC reliability the same way you’d treat any aggregator, as a complement rather than the certified system of record.

Blockdaemon

Blockdaemon sells directly to the exact buyer this article is written for: it serves 400+ institutions, including major banks and payment networks, and bundles production-grade Ethereum RPC endpoints with custody, staking, and tokenization infrastructure rather than offering RPC as a standalone self-serve product. High-availability node clusters with automated scaling and failover back the RPC layer.

Both SOC 2 Type II and ISO 27001 certifications are published, matching Chainstack and Quicknode as the only providers in this comparison holding both. Pricing is custom and institutional rather than self-serve — there’s no public plan tier to point to, which is itself consistent with the buyer Blockdaemon targets: procurement teams that expect a commercial negotiation, not a credit card checkout.

Limitations: No self-serve signup or public pricing means evaluation requires a sales conversation before a team can even see representative costs — a meaningfully slower path than deploying an endpoint from a console in minutes. Not a fit for teams that want to prototype before committing to a vendor relationship.

Fit for custodians and asset managers: Excellent for large institutions that already run a formal vendor-onboarding process and want custody, staking, and RPC bundled under one contract; less practical for a team that wants to deploy and test an endpoint today.

Ankr

Ankr holds SOC 2 Type II certification and runs a distributed node-operator model across 80+ chains, with the largest free evaluation tier in this comparison: a Freemium plan offering 200M API credits per month. Archive access, WebSocket support, and dedicated private endpoints are available from the Premium tier up.

ISO 27001 certification is not yet published as completed — as of this writing it’s described as a program underway rather than an achieved certification, which puts Ankr a step behind the dual-certified providers in this comparison on the compliance axis. The distributed operator model can also introduce more response-time variability than a single-operator infrastructure stack, a bigger concern for correctness-sensitive custody reconciliation than it would be for a latency-tolerant workload.

Limitations: ISO 27001 not yet completed. Distributed node-operator model may introduce response-consistency variability. No named enterprise support tier or public contractual SLA comparable to Chainstack’s or Quicknode’s.

Fit for custodians and asset managers: Moderate — the free tier is genuinely useful for evaluation and pre-production work, but the incomplete compliance pairing and infrastructure-consistency profile make it a harder sell for a production custody deployment.

Alchemy

Alchemy is one of the largest Ethereum RPC providers by developer mindshare, with archive access and debug/trace support on paid plans. Its platform layer — NFT APIs, Token APIs, and enriched transaction data — adds real value for custody platforms building portfolio views, since it abstracts some multi-call reconciliation patterns into single API calls rather than requiring them to be hand-assembled from raw logs.

Pay-as-you-go pricing runs $0.45 per million compute units (CU) for the first 300M CU per month, then $0.40 per million beyond that. The free tier (30M CU/month, 25 RPS) is a permanent plan rather than a trial — a genuine point in Alchemy’s favor for evaluation and pre-production use. Alchemy holds SOC 2 Type II certification but does not publish ISO 27001; for custody teams whose vendor risk policy requires both, that’s a specific, nameable gap rather than a general compliance shortfall. There is no standard self-serve dedicated-node tier — isolated infrastructure requires an enterprise agreement with custom pricing.

Budget-conscious teams scaling past the free tier should model Alchemy’s CU costs against their actual trace and archive call volume before committing, since method-weighted billing means the effective cost per audit-heavy call runs above the headline per-CU rate.

Limitations: No published ISO 27001 is a specific, nameable gap for dual-certification procurement requirements. No standard dedicated-node tier. Method-weighted CU billing makes archive-heavy audit workloads costlier than the sticker price implies.

Fit for custodians and asset managers: Moderate — strong developer experience and a genuinely permanent free tier, held back for regulated custody procurement by the missing ISO 27001 certification and the absence of a standard dedicated tier.

Quicknode

Quicknode includes archive access on all paid Ethereum plans, and debug_traceTransaction and WebSocket subscriptions are available across the paid tier ladder. It holds both SOC 2 Type II and ISO 27001 certification, matching Chainstack and Blockdaemon as the only providers here with the full dual-certification pairing.

The free option is a one-month trial (10M credits, 15 RPS) rather than a permanent standalone plan — a real, citable distinction from Chainstack’s and Alchemy’s permanent free tiers. Paid plans run from Build ($49/month, 80M credits, 50 RPS) through Accelerate ($249/month, 450M credits, 125 RPS) and Scale ($499/month, 950M credits, 250 RPS) up to several Business+ tiers, with Dedicated infrastructure and SSO reserved for Enterprise agreements. Pricing uses method-weighted credits, where trace and archive calls consume more credits than a standard read — teams running heavy audit-trace volume should model that against their actual call mix rather than the headline plan price, since it’s the same structural pattern that makes Alchemy’s sticker price understate archive-heavy costs.

Limitations: Method-weighted billing makes cost forecasting harder for audit-heavy trace workloads than Chainstack’s flat RU model. Dedicated infrastructure and SSO are Enterprise-only, so mid-market custody platforms share endpoints with the broader user base unless they negotiate an Enterprise contract.

Fit for custodians and asset managers: Strong — archive on every paid plan and the same dual-certification pairing as Chainstack and Blockdaemon, offset by a time-limited free tier and a cost model that climbs faster than the headline price suggests once trace-heavy workloads scale.

Getting started with Ethereum on Chainstack

Deploy a production Ethereum endpoint in a few minutes and connect it to a custody or reconciliation pipeline:

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, Sepolia, or Hoodi testnet
5. Deploy the node
6. Open Access and credentials and copy your HTTPS and WebSocket endpoints

For custody workloads running continuous eth_getLogs polling alongside on-demand trace calls, evaluate Dedicated Nodes after the initial deploy — both live inside the same project, so moving from a shared Global Node to isolated infrastructure doesn’t require re-architecting the integration.

The Ethereum tooling documentation covers setup for MetaMask, Remix, viem, Web3.py, ethers.js, Hardhat, and Foundry. See the Chainstack provider entry above for a worked eth_getLogs reconciliation example.

Need testnet ETH for integration testing? Grab some from the Chainstack Sepolia faucet or the Chainstack Hoodi faucet — both distribute up to 0.5 ETH every 24 hours. Note that Hoodi is archive-only on Chainstack; Sepolia supports both full and archive nodes.

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

⚡ Performance tip: For custody platforms running continuous eth_getLogs polling across hundreds of addresses, the Unlimited Node add-on bills a flat monthly rate instead of per-request. At 25–100 RPS sustained, the fixed cost is typically lower than per-request billing with overage.

Conclusion

For Ethereum custody and asset management in 2026, the decision comes down to one question: which providers have a published, current, dual-certification story (SOC 2 Type II and ISO 27001) alongside flat-rate archive access that doesn’t punish audit-heavy months.

• For production custody deployments prioritizing compliance and cost predictability together: Chainstack — full archive and debug/trace from the Growth plan, both certifications published, flat 1–2 RU pricing regardless of method, and MEV protection on by default
• For large institutions running a formal vendor-onboarding process: Blockdaemon — custody, staking, and RPC bundled under one contract with both certifications published, at the cost of a slower, sales-led evaluation path
• For dual-certified infrastructure with a self-serve signup: Quicknode — the same certification pairing as Chainstack, with a higher effective cost at scale for trace-heavy audit workloads
• For evaluation, prototyping, and pre-production environments: Alchemy or Ankr — solid technical capability and generous free tiers; each carries one specific, nameable compliance gap (missing ISO 27001) worth flagging before a production commitment
• For resilience layered on top of a certified primary provider: RouteMesh or Uniblock — genuinely useful for multi-provider failover and enriched portfolio APIs, but not a substitute for a directly auditable node operator

Frequently asked questions

Q: Does debug_traceTransaction require an archive node on Ethereum?

Yes. debug_traceTransaction and trace_transaction both require an archive node because they reconstruct the full EVM state at the time of execution. A full node keeps roughly the latest 128 blocks and prunes state beyond that, so it cannot serve either method for older transactions. Confirm archive and debug/trace access explicitly before signing a provider contract — don’t assume it’s included just because the provider lists “archive” as a feature.

Q: Which Ethereum RPC providers offer a permanent free tier for custody platform development and testing?

Chainstack (3M RU/month, no card required), Alchemy (30M CU/month), and Ankr (200M credits/month on its Freemium plan) all run permanent free tiers. Quicknode’s free option is explicitly a one-month trial rather than a standing plan. For a custody platform evaluating vendors before committing budget, a permanent free tier removes the pressure to make a compliance decision on an artificial deadline.

Q: How do I migrate a custody platform from a general-purpose RPC provider to a certified one without downtime?

Run both endpoints in parallel behind a feature flag or load balancer, mirror eth_getLogs and eth_getTransactionReceipt traffic to the new provider first to validate reconciliation output matches exactly, then cut over write traffic (transaction submission) last, once read parity is confirmed over a full settlement cycle. Verify the new provider’s archive depth actually covers your existing audit-trail retention requirement before decommissioning the old endpoint — don’t assume equivalent depth.

Q: How do I benchmark Ethereum RPC provider latency and consistency for custody workloads?

Custody workloads care more about consistency than average latency — a p99 spike on eth_getLogs during end-of-day reconciliation is more damaging than a slightly higher mean on eth_blockNumber. Test with your actual method mix: eth_getLogs at your typical block range, debug_traceTransaction on representative transactions, and WebSocket subscription stability over 24 hours. compare.chainstack.com tracks live cross-provider Ethereum performance for a quick top-level check; the Chainstack performance dashboard gives the same data broken down by method and region.

Q: Does MiCA compliance require my Ethereum RPC provider to be SOC 2 certified?

MiCA doesn’t name SOC 2 specifically — it requires custodians to maintain “robust operational and technical” controls and to run third-party vendor risk assessments. In practice, institutional counterparties (prime brokers, fund administrators, bank custody partners) increasingly require SOC 2 Type II and ISO 27001 as part of vendor onboarding regardless of what the regulation itself names. Choosing an uncertified provider doesn’t violate MiCA directly, but it lengthens the vendor risk assessment and may require compensating-controls documentation instead.

Q: What’s the real cost difference between Chainstack’s flat RU pricing and a method-weighted provider for a trace-heavy custody workload?

Chainstack bills 1 RU per full-node call and 2 RU per archive/debug/trace call, regardless of method — a flat multiplier with no per-method differentiation. Method-weighted providers charge substantially more for heavy calls: Chainstack’s own cost comparison cites method multipliers as high as 20–120x on Quicknode and 10–60x on Alchemy versus a standard call, depending on the method. For a workload with a meaningful share of debug_traceTransaction or historical-state calls, that gap compounds fast — model your actual method mix against each pricing page rather than comparing headline plan prices.

Additional resources

• How to get an Ethereum RPC endpoint in 2026
• Ethereum available methods — Chainstack Docs
• Ethereum logs tutorial series: logs and filters — Chainstack Docs
• Ethereum official developer documentation
• More Ethereum tutorials and articles on the Chainstack Blog
• Chainstack pricing