A single DeFi action on Ink rarely costs one RPC call. A swap checks token balances, reads pool reserves, simulates the route, estimates gas, submits the transaction, and watches for the confirmation event. Multiply that across thousands of users on a chain producing a block every second, and your RPC provider becomes the bottleneck for your entire application.
Ink is Kraken's DeFi-focused Ethereum Layer 2, built on the OP Stack and connected to the Optimism Superchain. It launched in December 2024 with 1-second blocks, ETH for gas, and direct integration with Kraken's exchange. The public endpoints work for a demo, but they cap throughput at low rates and restrict the debug and trace methods that production DeFi depends on.
This comparison breaks down 6 RPC providers that support Ink mainnet today, with pricing normalized so you can make a direct cost comparison.
What Makes Ink Different for RPC
Ink is a standard OP Stack chain, which means full EVM and eth_* JSON-RPC compatibility. The differences that affect your RPC choice come from how Ink is used and how it settles.
DeFi density at 1-second blocks. Ink positions itself as the house of DeFi for the Superchain. DEXs, lending markets, and perps generate a dense mix of reads, event subscriptions, and trace calls per user action. A block every second adds up to roughly 86,400 blocks per day, and an indexer that falls behind on ingestion is hard to catch back up.
Optimistic rollup finality. Ink settles to Ethereum as an optimistic rollup with a 7-day challenge window for Standard Bridge withdrawals. Soft confirmation lands in about a second, but anything that proves or reconciles a withdrawal needs historical state at a specific block height. That makes archive node access a practical requirement, not a nice-to-have.
Superchain interoperability. Ink shares OP Stack standards and native bridging with the rest of the Superchain. Applications that span multiple Superchain L2s benefit from a provider that serves those chains consistently, so you are not stitching together different APIs and rate limits per network.
Restricted methods on public endpoints. Ink's public RPC endpoints whitelist methods. A call to debug_traceBlockByNumber on the public Gelato endpoint returns rpc method is not whitelisted. Trace and debug access on Ink means a paid plan from a provider that exposes those namespaces.
What to Look for in an Ink RPC Provider
Not every criterion matters equally. These factors carry the most weight for DeFi infrastructure on Ink:
- Latency - With 1-second blocks, your RPC round-trip needs to stay well under that window so reads reflect current state and your indexer keeps pace.
- Archive node access - Withdrawal proofs, historical balances, and DeFi analytics all query state at past block heights. Archive access is essential for reconciliation and indexing.
- Trace and debug APIs -
debug_traceTransactionand related methods are how you diagnose a failed swap or a liquidation that did not fire. Public Ink endpoints restrict these, so confirm your provider exposes them. - WebSocket support - Monitoring pool events, fills, and price updates depends on persistent WebSocket connections rather than polling. Confirm stable WSS endpoints.
- Pricing transparency - Some providers bill in compute units, where a single
eth_callcosts 1 unit but adebug_traceTransactioncan cost 40 to 100. On a trace-heavy DeFi workload, opaque multipliers cause bill shock. - Superchain coverage - If you build across the Superchain, a provider that serves Ink alongside Optimism, Base, and other OP Stack chains keeps your infrastructure consistent.
1. Dwellir
Dwellir provides Ink RPC with a 1:1 pricing model. Every API response counts as one request, regardless of method complexity. No compute units, no multipliers. A debug_traceTransaction costs the same as an eth_getBalance.
Key features:
- 140+ supported networks, including Ink and other Superchain L2s
- Archive nodes included on all plans
- Trace and Debug namespaces on Ink (reth client, with
trace_*,debug_*, andtxpoolsupport) - WebSocket on all paid plans
- European infrastructure
- Autoscaling on paid plans with capped overage rates
Pricing:
| Plan | Monthly Cost | Responses Included | RPS (Burst) | Overage |
|---|---|---|---|---|
| Free | $0 | 100,000/day | 20 | - |
| Developer | $49 | 25M | 100 (500) | $5/M |
| Growth | $299 | 150M | 500 (2,500) | $3/M |
| Scale | $999 | 500M | 5,000 (10,000) | $2/M |
The 1:1 model is directly relevant to Ink workloads. DeFi applications that lean on trace APIs and event subscriptions cost significantly more on providers that apply compute unit multipliers to complex methods. The Ink endpoint runs on reth with full trace and debug access, which public endpoints do not offer. At the Scale tier, $2 per million overage is among the lowest rates available.
Best for: Teams that need predictable costs at scale, especially DeFi applications where trace, debug, and historical-state calls are frequent.
2. Alchemy
Alchemy supports Ink mainnet at ink-mainnet.g.alchemy.com with archive data and its broader OP Stack and Superchain tooling. The platform bills in compute units (CU), where method complexity determines cost per call.
Key features:
- 70+ supported networks with deep OP Stack coverage
- Archive nodes and WebSocket included
- Trace API available
- Enhanced APIs (Transfers, Token, NFT) that work across Superchain chains
- Mature SDKs and developer tooling
Pricing:
| Plan | Monthly Cost | Compute Units | RPS | Overage |
|---|---|---|---|---|
| Free | $0 | 30M CU/month | 25 | - |
| Pay-as-you-go | Variable | First 300M CU | - | $0.45/1M CU |
| Pay-as-you-go (300M+) | Variable | 300M+ CU | - | $0.40/1M CU |
| Enterprise | Custom | Custom | Custom | Custom |
The free tier offers 30M compute units, though complex methods like debug_traceTransaction consume far more CU per call than simple reads, so effective request counts run lower than headline numbers suggest. Alchemy's strength on Ink is consistency: if you already build across Optimism, Base, and other Superchain chains, the same APIs and tooling extend to Ink.
Best for: Teams building across the Superchain that want consistent tooling and enhanced APIs, and are comfortable with compute unit billing.
3. QuickNode
QuickNode runs one of Ink's official public endpoints (rpc-qnd.inkonchain.com), so it operates Ink infrastructure directly. Paid plans add Streams and Webhooks, useful for building event-driven DeFi notifications.
Key features:
- 88+ supported networks
- Archive nodes and WebSocket included
- Trace API available
- QuickNode Streams and Webhooks on paid tiers
- Operates an official Ink public endpoint
Pricing:
| Plan | Monthly Cost | API Credits | RPS | Overage |
|---|---|---|---|---|
| Free Trial | $0 | 10M/month | 15 | - |
| Build | $49 | 80M | 50 | $0.62/M |
| Accelerate | $249 | 450M | 125 | $0.55/M |
| Scale | $499 | 950M | 250 | $0.53/M |
| Business | $999 | 2B | 500 | $0.50/M |
QuickNode Streams provide push-based data delivery rather than constant polling, which suits monitoring Ink pool events and fills. The credit model uses multipliers similar to compute units, so heavy trace usage consumes credits faster. At the Business tier ($999/month), QuickNode caps RPS at 500, compared to Dwellir's 5,000 RPS (10,000 burst) at the same price point.
Best for: Teams that want event-driven infrastructure (Streams and Webhooks) from a provider that operates Ink's core public endpoints.
4. dRPC
dRPC serves Ink at ink.drpc.org and routes requests across a decentralized network of independent node operators, with a generous free tier for development.
Key features:
- 110+ supported networks
- Archive nodes and WebSocket included
- Trace API on Growth tier and above
- Decentralized routing across multiple node providers
- MEV protection on paid tiers
- Accepts crypto payments
Pricing:
| Plan | Monthly Cost | Included | RPS | Notes |
|---|---|---|---|---|
| Free | $0 | 210M CU/month | 100 | 100 RPS on free tier |
| Growth | Pay-as-you-go | - | 5,000 | $6/1M requests |
| Enterprise | Custom | From 300M req/month | Custom | Volume discounts |
For teams prototyping Ink integrations, 210M compute units at 100 RPS provides substantial runway before paid tiers. The Growth plan charges $6 per million requests at 5,000 RPS, competitive for high-throughput workloads, though per-request costs sit higher than the volume tiers at Dwellir or QuickNode.
Best for: Teams in early development that want maximum free-tier capacity, or high-RPS workloads that need 5,000 requests per second without an enterprise contract.
5. Tenderly
Tenderly runs an official Ink public endpoint (rpc-ten.inkonchain.com) and brings a development toolkit that is hard to match: transaction simulation, full execution traces, and the ability to fork Ink mainnet state into virtual test environments.
Key features:
- 80+ supported networks
- Archive nodes and full execution traces
- Transaction simulation and debugging
- Virtual environments (fork Ink mainnet state)
- Real-time alerting
- Operates an official Ink public endpoint
Pricing:
Tenderly uses Tenderly Units (TU) with variable costs per method type:
| Method Type | TU Cost |
|---|---|
| Read | 1 TU |
| Compute | 4 TU |
| Write | 20 TU |
| Debug/Trace | 40 TU |
| Plan | Monthly Cost | Tenderly Units | Rate Limit |
|---|---|---|---|
| Free | $0 | 25M TU/month | 10 TU/s |
| Starter | $50 | 35M TU | 20 TU/s |
| Pro | $500 | 350M TU | 300 TU/s |
The unit multipliers are steep for trace-heavy work. A debug_traceTransaction at 40 TU means 25M free TU translates to 625,000 trace calls, though pure reads go much further. Tenderly's real value on Ink is its tooling: forking mainnet state to simulate a swap or liquidation before deploying is powerful for teams building complex DeFi logic.
Best for: Development and QA teams that need to simulate and debug Ink DeFi flows in forked environments before production.
6. Gelato
Gelato is the provider behind Ink's default public endpoint (rpc-gel.inkonchain.com) and a core part of Ink's infrastructure. Gelato deployed Ink as a Rollup-as-a-Service chain for Kraken and runs one of the permissionless fault-proof challengers that secure withdrawals.
Key features:
- Operates Ink's default public RPC and WebSocket endpoints
- Runs a permissionless fault-proof challenger on Ink
- Rollup-as-a-Service platform for the broader Superchain
- WebSocket support included
Pricing:
Gelato's public Ink endpoint is free to start but rate-limited and restricts trace and debug methods. Production RPC is available through Gelato's Web3 Services platform on usage-based plans rather than fixed published tiers, so pricing depends on your request volume and feature needs. Contact Gelato for production quotes.
Best for: Teams that want RPC from the team that operates Ink's core infrastructure, or that are already using Gelato's Rollup-as-a-Service and automation products.
Provider Comparison
| Provider | Free Tier | Entry Paid | Archive | WSS | Trace API | RPS (Max Paid) | Pricing Model | Networks |
|---|---|---|---|---|---|---|---|---|
| Dwellir | 100K/day | $49/mo | Yes | Yes | Yes | 5,000 (10K burst) | 1:1 requests | 140+ |
| Alchemy | 30M CU/mo | Pay-as-you-go | Yes | Yes | Yes | Custom | Compute units | 70+ |
| QuickNode | 10M credits/mo | $49/mo | Yes | Yes | Yes | 500 | API credits | 88+ |
| dRPC | 210M CU/mo | $6/1M req | Yes | Yes | Yes (paid) | 5,000 | CU / requests | 110+ |
| Tenderly | 25M TU/mo | $50/mo | Yes | Yes | Yes | 300 TU/s | Tenderly Units | 80+ |
| Gelato | Public endpoint | Usage-based | Paid | Yes | Paid | Custom | Usage-based | Multi |
Cost at 100M Monthly Requests
For an Ink DeFi application making 100M API calls per month (a mix of reads, writes, and occasional traces):
| Provider | Estimated Monthly Cost | Notes |
|---|---|---|
| Dwellir (Growth) | $299 (150M included) | 1:1 pricing, no method multipliers |
| Alchemy | Varies by method mix | CU multipliers make estimates imprecise |
| QuickNode (Scale) | $499 (950M credits) | Credit multipliers apply |
| dRPC (Growth) | ~$600 | $6/M at pay-as-you-go |
| Tenderly (Pro) | $500 (350M TU) | Heavy trace usage consumes TU fast |
| Gelato | Quote-based | Usage-based pricing via Web3 Services |
Direct cost comparison across compute-unit providers is imprecise because your actual bill depends on your method mix. Providers using 1:1 request billing give the most predictable costs, which matters on a trace-heavy DeFi chain like Ink.
Choosing the Right Provider
For most teams building on Ink, the decision comes down to three scenarios.
Best all-round choice: Dwellir. The 1:1 pricing model removes the guesswork of compute unit billing, which matters on Ink where DeFi workflows generate a dense mix of reads, event subscriptions, and trace calls. Archive nodes and full trace and debug access come on all paid plans, covering the historical-state and debugging needs that public Ink endpoints do not. At the Scale tier, 5,000 RPS with 10,000 burst and $2/M overage gives substantial headroom for production DeFi.
Best for Superchain-native tooling: Alchemy. If your application spans Optimism, Base, and other OP Stack chains, Alchemy's consistent APIs and enhanced data endpoints extend cleanly to Ink. That consistency is worth the compute unit model for teams already invested in the platform.
Best for development and testing: dRPC or Tenderly. dRPC's 210M CU free tier at 100 RPS is the most generous sandbox for prototyping. Tenderly adds the ability to fork Ink mainnet state for simulation and debugging, which is invaluable for testing complex swap and liquidation logic before going live.
Frequently Asked Questions
What is the best Ink RPC provider?
Dwellir offers the best all-round choice for Ink with 1:1 pricing that eliminates compute unit complexity. This matters on Ink because DeFi workflows generate a dense mix of reads, event subscriptions, and trace calls. Archive nodes and trace APIs are included on all paid plans. For OP Stack and Superchain-native tooling, Alchemy is the strongest alternative.
What is Ink blockchain?
Ink is a DeFi-focused Ethereum Layer 2 built and incubated by Kraken. It runs on the OP Stack and is part of the Optimism Superchain, with chain ID 57073, 1-second block times, and ETH for gas. It launched in December 2024 as an optimistic rollup that settles to Ethereum, and it was the first Superchain network to launch with multiple permissionless fault-proof challengers.
Are there free Ink RPC endpoints?
Yes. Ink publishes public endpoints from Gelato (rpc-gel.inkonchain.com), QuickNode (rpc-qnd.inkonchain.com), Tenderly (rpc-ten.inkonchain.com), and dRPC (ink.drpc.org), but they are rate-limited and restrict debug and trace methods. Provider free tiers go further: dRPC offers 210M compute units monthly, Alchemy 30M, Tenderly 25M Tenderly Units, and Dwellir 100K requests per day.
What RPC performance does Ink require?
Ink produces blocks every second, so a slow RPC connection falls behind on block ingestion quickly. DeFi applications on Ink need stable WebSocket connections for event monitoring, archive nodes for historical state and withdrawal proofs, and trace or debug APIs for diagnosing failed swaps and liquidations. Public endpoints restrict trace and debug, so production workloads need a paid plan.
Related Resources
- RPC Providers Without Compute Units - Why transparent pricing matters for Ink's trace-heavy DeFi workloads
- Self-Hosted vs Managed RPC Nodes - Evaluate whether to run your own Ink node or use a managed provider
Getting Started
Ink's public endpoints are fine for a prototype, but production DeFi needs higher throughput, archive access, and the trace and debug methods that public endpoints restrict. The providers listed here all support Ink today, with different trade-offs in pricing model and tooling.
If you are evaluating Ink RPC for production, test latency and reliability across 2-3 providers with your actual workload patterns. Free tiers exist across most options, so use them.
Ready to build on Ink? Get started with Dwellir's Ink RPC endpoints or contact the Dwellir team to discuss infrastructure requirements for your DeFi application.
