Best Ink RPC providers for production DeFi apps in 2026

Ink is an Ethereum layer 2 on the OP Stack, incubated by Kraken as a DeFi home on the Optimism Superchain, with ETH for gas and roughly one-second blocks. DefiLlama shows about $205 million of TVL on Ink as of October 9, 2026, and Tydro, a lending market built on the Aave v3 codebase, holds about $133 million of that.

The 2026 constraint when comparing the best Ink RPC providers is the sequencer. Ink streams subblocks (formerly Flashblocks) roughly every 200 ms before a block is sealed, and its docs say that reading pre-confirmed state over JSON-RPC, with eth_call or eth_getBalance on the pending tag, needs a provider that supports subblocks. Pending transactions never leave the sequencer, so there is no public mempool to subscribe to. Ink’s docs list public endpoints and also link to a list of vendors offering private RPC endpoints.

This guide compares six Ink RPC providers on Ink Mainnet, covering pricing, archive and trace access, free tiers and support.

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

Ink total value locked, DefiLlama, October 9, 2026.

Why RPC provider choice matters for Ink

A one-second block time turns every historical job into a large one. A backfill from genesis spans a very large number of blocks, and a 10,000-block eth_getLogs window covers under three hours of chain time, so an indexer written against a slower chain issues far more requests here. The billing model decides whether that is a rounding error or a line item. Chainstack bills request units with no per-method weights (1 RU full, 2 RU archive, debug and trace), while Alchemy and Quicknode weight each method, so the sticker price says little about the bill for log-heavy or trace-heavy workloads.

The second concern is behavior that is specific to an OP Stack chain with a sequencer. Filters created on a load-balanced endpoint can disappear between calls, eth_getProof only serves the latest block on Chainstack Global Nodes, and every transaction pays an L1 data fee on top of L2 gas. Seven criteria separate production-grade Ink endpoints from basic ones:

• Cost predictability and pricing model. Flat request units versus method-weighted compute units or credits, and what a heavy method like eth_getLogs really costs at your volume.
• Archive and historical data access. History depth, debug_* and trace_* coverage, and what historical reads cost.
• Throughput stability under load. RPS ceilings per plan, and sustained versus burst behavior.
• Support quality. Community-only on free tiers, response-time commitments on paid tiers, 24/7 escalation on enterprise plans.
• Free-tier reality. A permanent plan versus a time-limited trial, and what the free tier leaves out (archive, trace, wide eth_getLogs ranges).
• Dedicated nodes, SLA and compliance. When a shared endpoint stops being enough, and which providers publish SOC 2 or ISO 27001 attestations.
• Ink-specific behavior. Subblocks support, WebSocket subscriptions, mempool expectations, and testnet availability (Ink Sepolia).

Ink RPC providers compared

The table below summarizes public positioning as of October 2026. Ink’s own RPC page lists Alchemy, Gelato, QuickNode, Tenderly, dRPC, Uniblock and BoltRPC. Alchemy, Quicknode and Uniblock are covered here alongside Chainstack, Dwellir and RouteMesh, which that list does not include; Gelato, Tenderly, dRPC and BoltRPC are left out to keep this comparison to six.

Provider	Pricing model	Free tier	Dedicated nodes	Archive & trace	Ink testnet
Chainstack	Flat RU billing: 1 RU full, 2 RU archive, debug and trace; Unlimited Node add-on	Developer plan: 3M RU/month, 25 RPS	Yes, on request (Dedicated Nodes, op-reth, Full; Archive to confirm)	Archive from Growth; debug_* and trace_* on paid plans	Yes (Ink testnet on Global Nodes)
Dwellir	Flat: 1 response = 1 credit; $49, $299, $999 plans	20 responses/s, 100,000 responses/day	Dedicated node clusters for qualified teams	Trace and debug on paid plans	Not documented
RouteMesh	Per-request, listed at $3.00/M and $6.00/M for common methods	Free community endpoint, no API key	Not documented	Depends on routed provider; 68 methods listed	Yes (Ink Sepolia, 56 methods listed)
Uniblock	Compute units; Growth $49/month for 500M CU	Startup: 40M CU/month, 1,000 CU/s	Enterprise plan	Debug, EVM and Trace method groups documented	Yes
Alchemy	Compute units; pay-as-you-go $0.525 per 1M CU	30M CU/month, 15 RPS	Dedicated Clusters via sales (Ink coverage not stated)	Debug API; Trace API not listed as available on Ink	Yes
Quicknode	Credits; Build $49/month for 80M credits	1-month trial: 10M credits, 15 RPS	Enterprise plan	Archive, no pruning; Debug API	Yes

How to choose an Ink RPC provider

1. Pricing model: flat versus weighted, and what that means at scale

Flat request-unit billing charges every call the same, while compute-unit and credit models multiply heavy methods. The normalization formula is: true cost per call = (method’s CU or credit weight × price per million units) ÷ 1,000,000, and you multiply that by monthly call volume for the real bill.

For eth_getLogs at each provider’s entry paid tier, the arithmetic looks like this:

Provider	eth_getLogs weight	Entry paid tier	Effective cost per 1M calls
Chainstack	1 RU (recent), 2 RU (archive range)	Growth, $49/month for 20M RU	About $2.45 recent, $4.90 archive
Dwellir	1 credit	Developer, $49/month for 25M responses	About $1.96
RouteMesh	Per-request	Listed on its Ink page	$3.00 to $6.04
Uniblock	89 CU (published cross-chain average, varies with block range)	Growth, $49/month for 500M CU	About $8.72
Alchemy	60 CU	Pay as you go, $0.525 per 1M CU	About $31.50
Quicknode	20 credits	Build, $49/month for 80M credits	About $12.25

The table assumes the plan allotment is fully used with no overage, and weights come from each provider’s published credit or CU table as of October 2026. The Alchemy figure uses its pay-as-you-go list rate rather than a fixed plan allotment, and Uniblock’s figure uses the weighted-average eth_getLogs weight from its Compute Units reference, which is not Ink-specific. To model your own method mix instead of one method, use the interactive cost calculator.

Four of the six providers; RouteMesh and Uniblock are in the table above. Chainstack shows 1 RU near the tip and 2 RU for archive-range queries.

2. Archive, trace and debug method access

Historical state queries (eth_call at a past block, balances at a past block) and the debug_* and trace_* namespaces need archive data. On Ink, Chainstack serves archive data from the Growth plan up and debug_* and trace_* on paid plans, through Ink’s debug and trace support. Only the default native tracers are available on Chainstack Ink nodes; the extended flatCallTracer, muxTracer and erc7562Tracer are not. Quicknode documents archive nodes with no pruning and the Debug API on Ink. Alchemy lists the Debug API but does not list the Trace API as available on Ink. Dwellir and Uniblock both document debug and trace access, so check the exact methods you call before committing. Archive reads are also where a cost model matters most: see Chainstack’s archive data page for the workloads that live there.

3. Free-tier reality

Chainstack has a free Developer plan with no time limit stated, Alchemy, Dwellir and Uniblock list free plans with no stated time limit, and Quicknode offers a one-month trial. The free tiers are not equivalent: Chainstack’s Developer plan gives 3M RU per month at 25 RPS but no archive data or debug and trace APIs, and caps eth_getLogs at 100 blocks per request. Alchemy’s Free plan gives 30M CU per month at 15 RPS, Dwellir allows 100,000 responses a day, and Uniblock’s Startup plan gives 40M CU. If you evaluate on the free tier, test the exact methods you need: a free plan that rejects your trace call will not tell you how the paid plan behaves.

4. When dedicated infrastructure matters

Three scenarios push past shared endpoints. First, sustained load beyond a plan’s RPS ceiling, which on Chainstack ranges from 25 RPS on Developer to 600 RPS on Business. Second, custom configuration, such as larger eth_getLogs block ranges, which Dedicated Nodes support on request. Third, isolated capacity for a compliance review or a data pipeline that must not share a rate limit with other tenants.

5. Ink-specific data access

Ink has no public mempool: eth_subscribe("newPendingTransactions") returns an ID and delivers nothing, as described in Chainstack’s mempool configuration guide. Filters created with eth_newFilter live on a single backend of a load-balanced endpoint, so poll eth_getLogs over an explicit range or hold a WebSocket subscription. Chainstack’s limits page lists the block-range caps and the latest-block-only eth_getProof window on Ink. Subblocks are the open question: Ink’s docs say you need a provider that supports them for pre-confirmed reads, and Chainstack’s Ink documentation does not mention subblocks support, so confirm it with any provider before you build a pre-confirmation flow.

6. Support quality, by tier

Chainstack’s free Developer plan has community support, every paid plan includes Standard support with a response under 24 hours (24×5), and the Professional ($100/month) and Premium ($1,000/month) tiers add 24×7 coverage with under 6 hours and under 1 hour response targets, per the enterprise support and SLA page. Alchemy lists a 48-hour target on Free and 24 hours on pay-as-you-go, with Bronze, Silver and Gold add-ons at 12, 4 and 2 hours. Quicknode lists dedicated support with a premium SLA on Enterprise. Read the tier name, not just “support included”.

7. Latency consistency versus average latency

Averages hide the slow requests that break a liquidation bot or a frontend. Compare p95 and p99 latency under your own request mix, from the region your users or servers sit in, over a few hours rather than a few minutes.

⚡ Benchmark before you commit: Neither the Chainstack performance dashboard nor compare.chainstack.com covers Ink yet. Run a quick latency test against each provider’s endpoint from your target region before committing. A curl loop or k6 script hitting eth_blockNumber and one heavier method (eth_getLogs, eth_call at a past block) is enough to surface meaningful p95 and p99 differences.

Choose by use case

Ink DeFi apps and trading interfaces

DeFi frontends on Ink read balances, positions and pool state through eth_call (often batched through Multicall3), follow new blocks over WebSocket and need an accurate L1 data fee estimate before a swap. With no public mempool, there is no pending-transaction stream to build on, so the data path is block headers and logs. The provider needs stable p95 latency, a WebSocket that stays up, and a bill that does not move with every traffic spike.

Chainstack’s flat billing and WebSocket endpoints suit this profile, and RouteMesh adds multi-provider failover for frontends that cannot tolerate a single-provider outage. Alchemy and Quicknode offer broader surrounding tooling if your app already uses it, including webhooks on both, Streams on Quicknode and a bundler API on Alchemy.

Indexers, analytics and data pipelines

Indexers on Ink are dominated by eth_getLogs and by historical reads, and one-second blocks mean a range query reaches the provider’s block-range cap quickly. On Chainstack, the cap is 10,000 blocks on Growth and above (100 on Developer), and any call 127 or more blocks behind the tip bills as archive at 2 RU. Trace-based analytics need debug_* or trace_* access, and Alchemy’s Ink page does not list the Trace API as available.

For heavy backfills, flat per-response billing (Chainstack, Dwellir) keeps the bill linear, while method-weighted models make a log scan cost many times a simple read. Chainstack Dedicated Nodes and Dwellir’s flat-rate RPS plans remove per-request metering entirely, and Uniblock’s unified API suits teams that also want token or NFT data next to raw RPC.

Enterprise DeFi infrastructure

An institutional team running on Ink needs vendor attestations, contractual uptime and a support path with named response times. Chainstack holds both SOC 2 Type II and ISO 27001 certifications and publishes a 99.9% quarterly uptime commitment with service credits. Quicknode lists SOC 2 Type 2 and ISO/IEC 27001, and Alchemy lists a SOC 2 Type II report on its trust center but publishes no ISO 27001. For RouteMesh, Uniblock and Dwellir, certifications were not confirmed during research, so ask them directly.

For regulated workloads, pair Dedicated Nodes with the Professional or Premium support tier, and put the SLA terms in the contract rather than relying on a pricing page.

Ink RPC provider breakdown

Chainstack

Chainstack runs Ink RPC on Global Nodes in archive mode, with debug_* and trace_* namespaces on paid plans, and offers Dedicated Nodes on isolated op-reth infrastructure in Full mode, with Archive to be confirmed with the Chainstack team. Billing is flat per request: 1 RU for a full request and 2 RU for archive, debug and trace calls. Ink Mainnet Global Nodes were announced on October 6, 2026, Chainstack’s October 8 changelog added Global Nodes for the Ink testnet (the Ink tooling and Networks docs still list Mainnet only), and Dedicated Nodes were available before either.

The Developer plan is free with 3M RU per month and 25 RPS. Per Chainstack’s pricing page, Growth is $49 per month for 20M RU and 250 RPS, Pro is $199 for 80M RU and 400 RPS, and Business is $499 for 200M RU and 600 RPS, with overage billed per million RU. Archive data starts at Growth, and Dedicated Nodes start at Pro. The Unlimited Node add-on, available from Growth, replaces per-request billing with a flat monthly fee tied to an RPS tier, from $149 per month at 25 RPS. Payment in crypto is supported on all plans. On Ink, a request 127 or more blocks behind the tip counts as archive, which is about two minutes of chain time, so historical reads bill at 2 RU, as described in the request units guide.

Chainstack holds SOC 2 Type II and ISO 27001 certifications, and its enterprise SLA page lists a 99.9% quarterly uptime commitment.

Limitations: The Ink testnet on Global Nodes is only days old, with no Chainstack faucet listed for it at the time of writing. The Developer plan has no archive data, no debug and trace, and a 100-block eth_getLogs cap. Only the default native tracers are available, and subblocks support is not documented. Chainstack’s docs list Ink Global Nodes as one “Worldwide” location on the Chainstack Partner Network, with no region choice documented for shared endpoints.

Fit by workload:

• DeFi apps and trading interfaces: Strong. Flat billing and WebSockets fit the read-heavy path, but subblocks support is undocumented.
• Indexers and analytics: Excellent for log scans and archive reads, where RU billing without per-method weights and Dedicated Nodes keep cost linear.
• Enterprise DeFi: Excellent. Both certifications, a published SLA and tiered support all in one place.

Dwellir

Dwellir serves Ink Mainnet over HTTPS and WebSocket with flat billing where one response equals one API credit, on a free tier of 20 responses per second and 100,000 responses a day and paid shared plans at $49, $299 and $999 per month. Those plans include 25M, 150M and 500M responses, with overages of $5, $3 and $2 per million, according to its Ink docs.

Paid plans list trace and debug APIs, and Growth and Scale list a 10,000-block eth_getLogs range. Dwellir also sells flat-rate RPS plans from $119 per month at 25 RPS, offers dedicated node clusters for qualified teams, and accepts crypto payment on every plan.

Limitations: The free tier is capped at 100,000 responses a day. Dwellir’s Ink page documents Mainnet only, and SOC 2 or ISO 27001 attestations were not confirmed during research, so enterprise buyers should request them. Subblocks support was not documented.

Fit by workload:

• DeFi apps and trading interfaces: Good. Flat pricing and WebSockets work, but there is no documented failover layer.
• Indexers and analytics: Strong. Flat per-response billing keeps log scans cheap, and flat-rate RPS plans remove metering.
• Enterprise DeFi: Moderate, pending certifications and an enterprise contract.

RouteMesh

RouteMesh is an RPC routing layer that serves Ink (chain ID 57073) through a single endpoint, with a free community endpoint that needs no API key and 68 supported methods listed on its Ink page. Requests are routed across several upstream providers with health scoring and automatic failover, and each API key can use an economy or a performance routing strategy.

Its Ink page lists $3.00 per million and $6.00 per million price points for common methods, and $6.00 per million for WebSocket notifications, as of October 2026. Confirm the figures on the live page, because the columns are easy to misread. The free endpoint sends reads to community-run public nodes and sends transactions to premium infrastructure, which is fine for development and testing. RouteMesh supports 1,000+ networks, so it also suits teams that run the same stack across many chains.

Limitations: History depth, debug_* and trace_* coverage and subblocks support depend on the upstream provider a request lands on, so test the methods you rely on. The 68 listed methods should be checked against your needs, and dedicated nodes are not documented for Ink. Per-request pricing scales linearly with volume.

Fit by workload:

• DeFi apps and trading interfaces: Strong. Multi-provider failover is the main draw for frontends.
• Indexers and analytics: Moderate. Verify archive and trace coverage before routing a backfill through it.
• Enterprise DeFi: Good, with contract terms and certifications to confirm directly.

Uniblock

Uniblock exposes Ink Mainnet and Ink Sepolia through a unified JSON-RPC endpoint that auto-routes across 55+ upstream providers, with Debug, EVM and Trace method groups documented for Ink. Ink’s own RPC page lists Uniblock among its vendors. Beyond raw RPC, Uniblock offers higher-level unified APIs for token, NFT and market data and webhooks.

Plans are metered in compute units. Startup is free with 40M CU per month and 1,000 CU/s across 2 projects, Growth is $49 per month for 500M CU at 2,000 CU/s, Pro is $199 for 2B CU, and Business is $549 for 5.5B CU, with annual billing discounts on the pricing page. Enterprise adds custom throughput, dedicated nodes and tailored SLAs.

Limitations: Compute-unit billing means heavier methods consume more of the allotment, and the per-method weights are documented separately in its Compute Units overview. Archive depth and trace behavior come from whichever upstream provider serves the request, and subblocks support was not documented in the pages reviewed.

Fit by workload:

• DeFi apps and trading interfaces: Good. Pooled upstreams give headroom, though latency depends on routing.
• Indexers and analytics: Strong when you also want token and NFT data through the same API.
• Enterprise DeFi: Moderate, until an Enterprise agreement and attestations are confirmed.

Alchemy

Alchemy serves Ink Mainnet and Ink Sepolia with the RPC API, Debug API, WebSockets, Webhooks, Token API and Bundler API, but its Ink page shows the Trace API as a “Request support” item rather than available. Alchemy bills in compute units, with a Free plan of 30M CU per month at 15 RPS and pay-as-you-go at $0.525 per million CU with 300 RPS included.

According to Alchemy’s CU table, eth_blockNumber costs 10 CU, eth_call 26 CU, eth_getLogs 60 CU and debug_traceTransaction 40 CU. At $0.525 per million CU, one million eth_getLogs calls bill about $31.50, so Alchemy’s cost curve steepens quickly past the free tier for log-heavy workloads; model your own mix first. Support targets are 48 hours on Free and 24 hours on pay-as-you-go, with Bronze, Silver and Gold add-ons, and Enterprise starts at 1,000 RPS.

Alchemy lists a SOC 2 Type II report on its trust center, and no ISO 27001 attestation was found. The pricing page lists Free, Pay As You Go and Enterprise tiers and no self-serve dedicated nodes, though Alchemy sells Dedicated Clusters through sales (Ink coverage is not stated).

Limitations: Trace API not listed as available on Ink, method-weighted billing that makes heavy reads expensive, and no self-serve dedicated nodes. Subblocks support was not documented on its Ink page.

Fit by workload:

• DeFi apps and trading interfaces: Strong. Mature tooling, webhooks and account abstraction help consumer apps.
• Indexers and analytics: Limited. No listed Trace API and a 60 CU eth_getLogs make heavy scans costly.
• Enterprise DeFi: Good, with a SOC 2 Type II report and custom SLAs on Enterprise, but no ISO 27001.

Quicknode

Quicknode supports Ink Mainnet and Ink Sepolia (chain IDs 57073 and 763373) with the Ethereum JSON-RPC API, Debug API and OP-Node API, WebSocket access, and archive nodes without pruning, plus Streams and Webhooks. Its entry offering is a one-month free trial with 10M credits at 15 RPS rather than a permanent plan.

Paid tiers are Build at $49 per month (80M credits, 50 RPS), Accelerate at $249 (450M credits, 125 RPS) and Scale at $499 (950M credits, 250 RPS) and Business at $999 (2B credits, 500 RPS). Its credit table puts Ink methods at 20 credits each, with trace and debug calls on a 2x multiplier. At 20 credits per call, Build’s 80M credits cover about 4M eth_getLogs calls, so teams scaling past the trial often find credit consumption outpaces the headline price. Enterprise adds dedicated clusters, SSO and RBAC, and a premium SLA.

Quicknode lists SOC 1 and SOC 2 Type 2 reports and ISO/IEC 27001 certification on its security page.

Limitations: There is no permanent free tier, only a time-limited trial, and its Ink API overview lists the Debug API rather than a separate trace_* namespace. Method-weighted credits make heavy reads harder to forecast, and subblocks support was not documented in the pages reviewed.

Fit by workload:

• DeFi apps and trading interfaces: Strong. Broad tooling, Streams and archive nodes cover most needs.
• Indexers and analytics: Good, as long as you budget for credit multipliers on heavy and trace calls.
• Enterprise DeFi: Strong. Certifications and Enterprise terms are in place.

Getting started with Ink on Chainstack

Deploy an Ink endpoint in a few steps, using Chainstack’s Ink documentation for the details:

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

The Ink testnet is deployable on Global Nodes for testing. For sustained high-volume traffic, add Dedicated Nodes or the Unlimited Node add-on from the same project.

const { JsonRpcProvider, formatEther } = require("ethers");

const provider = new JsonRpcProvider("YOUR_CHAINSTACK_ENDPOINT");

async function main() {
  // Ink Mainnet chain ID is 57073
  const network = await provider.getNetwork();
  console.log("Chain ID:", network.chainId.toString());

  const balance = await provider.getBalance("YOUR_WALLET_ADDRESS");
  console.log("Balance:", formatEther(balance), "ETH");
}

main();

📖 For the full integration guide, see the Chainstack Ink tooling documentation, which also covers ethers.js, viem, Foundry, Hardhat and MetaMask setup and the L1 data fee.

🤖 You can also access Chainstack Ink RPC directly from Claude Code, Cursor, Codex, Windsurf, Gemini CLI, GitHub Copilot, Antigravity, Claude.ai, or ChatGPT using Chainstack MCP. For a fuller agent stack — MCP, the Chainstack skill, llms.txt for context ingestion, and WebMCP for agentic browsers — see the Chainstack Agents page.

Conclusion

On Ink in 2026, the deciding criterion is how a provider bills and serves heavy and historical reads, because one-second blocks multiply every log scan and backfill. Match the billing model and history depth to your workload first, and treat latency, subblocks support and free-tier limits as the second pass.

• DeFi apps and consumer frontends: Chainstack for flat billing and WebSockets, RouteMesh for multi-provider failover, Alchemy or Quicknode if you already use their tooling.
• Indexers, analytics and backfills: Chainstack or Dwellir for flat per-response billing and trace access, Uniblock if you also want token and NFT APIs.
• Enterprise and regulated teams: Chainstack or Quicknode for SOC 2 and ISO 27001 attestations, with Dedicated Nodes and a contractual SLA.
• Teams that need an Ink Sepolia endpoint: Chainstack (Global Nodes, since October 8, 2026), Alchemy, Quicknode, Uniblock or RouteMesh.

Frequently asked questions

Q: Can I subscribe to pending transactions on Ink?

No. Ink is an OP Stack chain where pending transactions stay with the sequencer, so eth_subscribe("newPendingTransactions") and eth_newPendingTransactionFilter return an ID but deliver nothing. Build on new blocks, logs and, where your provider supports it, subblocks instead. Chainstack explains this in its mempool configuration guide.

Q: Which Ink RPC providers have a permanent free tier?

Chainstack (3M RU per month, 25 RPS), Alchemy (30M CU per month, 15 RPS), Dwellir (100,000 responses a day) and Uniblock (40M CU per month) list free plans with no stated time limit, while Quicknode offers a one-month trial. Check what each tier excludes: Chainstack’s Developer plan has no archive or debug and trace, and caps eth_getLogs at 100 blocks.

Q: How do I move an existing Ink app to a new RPC provider?

Ink exposes standard Ethereum JSON-RPC, so the main change is swapping the endpoint URL in your ethers.js, viem or web3.py client. Before cutting over, re-test eth_getLogs block-range limits, filter behavior across a load-balanced endpoint, and any subblocks or pending-tag reads, because these differ by provider.

Q: How do I measure Ink RPC latency?

The Chainstack performance dashboard and compare.chainstack.com do not track Ink, so run your own test. Hit each provider with eth_blockNumber and one heavier method such as eth_getLogs from your target region, and compare p95 and p99 over several hours rather than averages.

Q: Which Ink RPC providers publish SOC 2 and ISO 27001 attestations?

Chainstack holds SOC 2 Type II and ISO 27001, and Quicknode lists SOC 2 Type 2 and ISO/IEC 27001 on its security page. Alchemy lists a SOC 2 Type II report on its trust center but publishes no ISO 27001. For RouteMesh, Uniblock and Dwellir, request the attestations directly before procurement.

Q: Is flat or weighted pricing cheaper for Ink workloads?

It depends on the method mix. For eth_getLogs at entry paid tiers, Chainstack bills 1 to 2 RU per call, Quicknode 20 credits and Alchemy 60 CU, which works out to roughly $2.45 to $4.90, $12.25 and $31.50 per million calls. Light reads narrow the gap, so use the cost calculator with your own mix.

Additional resources

• Ink on Chainstack
• Ink network information — Ink Docs
• Ink block explorer
• Chainstack pricing