Best Ronin RPC Providers 2026: Complete Comparison Guide for Gaming dApps, Performance & Cost

Ronin blockchain powers the world's largest blockchain gaming ecosystem, processing millions of transactions daily for Axie Infinity and beyond. As Ronin transitions to Ethereum Layer 2 in 2026, choosing the right RPC provider is critical for your gaming dApp's performance, reliability, and costs. This guide compares the top 10 Ronin RPC providers to help you make an informed decision.

What is Ronin Blockchain?

Ronin is an EVM-compatible sidechain built by Sky Mavis specifically for gaming applications. Originally designed for Axie Infinity, Ronin has evolved into a permissionless gaming-focused blockchain with major upgrades planned for 2026.

Key specifications:

• Chain ID: 2020 (mainnet)
• Block Time: ~3 seconds
• Finality: 2 blocks (~6 seconds)
• Consensus: Delegated Proof of Stake (DPoS) with 22 validators
• Native Token: RON
• Compatibility: Full EVM compatibility (Cancun fork equivalent)
• 2026 Roadmap: Transition to Ethereum Layer 2 using zkEVM (Q1-Q2)

Why Your RPC Provider Matters for Gaming

RPC (Remote Procedure Call) providers serve as the critical infrastructure layer between your game and the Ronin blockchain. For gaming applications, provider choice directly impacts:

• User Experience: Lower latency = smoother gameplay and faster transactions
• Uptime: Gaming dApps need 99.9%+ reliability for player retention
• Transaction Costs: Gas-efficient routing saves players money
• Scalability: Peak gaming sessions require burst capacity
• WebSocket Support: Real-time game state synchronization depends on persistent connections

Top 10 Ronin RPC Providers Compared

Quick Comparison Table

1. Dwellir - Simplest Pricing for Gaming

Pricing: $49 to $999/month | Model: 1 request = 1 credit

Dwellir eliminates compute unit complexity with transparent 1:1 pricing—critical for gaming studios that need predictable infrastructure costs. Every RPC call costs one credit regardless of method complexity.

Key Features:

• Simple pricing across all methods (trace, debug, standard)
• 150+ blockchains with one API key
• 99.99% uptime SLA
• HTTPS, WSS, and GRPC support
• $2-5 per million overage (lowest in industry)
• Real-time WebSocket subscriptions for game state

Plans:

• Starter: $5 one-time (500K/day, 20 RPS)
• Developer: $49/mo (unlimited requests, 100 RPS)
• Growth: $299/mo (unlimited requests, 500 RPS)
• Scale: $999/mo (unlimited requests, 2,000 RPS)

Cost Example: 100M monthly requests = $299/mo (Growth plan)

Best For: Gaming studios needing predictable costs and multi-chain support for cross-platform games.

2. Alchemy - Comprehensive Gaming Platform

Pricing: $199 to custom | Model: Compute units (10-500 CU per request)

Alchemy provides comprehensive Web3 development tools including NFT APIs for gaming assets, enhanced WebSocket subscriptions for real-time gameplay, and simulation APIs for transaction previews.

Key Features:

• Extensive developer dashboard with analytics
• NFT and token APIs for in-game assets
• Webhooks and real-time notifications
• Transaction simulation for game mechanics
• Archive data access for historical game data
• Enhanced WebSocket subscriptions

Pricing:

• Free: 300M CU/month
• Growth: $199/mo (1.5B CU)
• Scale: $499/mo (6B CU)
• Enterprise: Custom pricing

Cost Example: 100M gaming requests ≈ $200-400/mo depending on method mix

Best For: Gaming teams needing comprehensive Web3 development tools and NFT infrastructure.

3. QuickNode - Global Gaming Performance

Pricing: $49 to $999+/month | Model: API credits (1-500 per request)

QuickNode operates a globally distributed network with presence in 30+ regions—essential for gaming applications with worldwide player bases requiring consistent low latency.

Key Features:

• Global edge network for low-latency gaming
• Add-ons marketplace for gaming-specific features
• GraphQL support for efficient data queries
• Performance analytics and monitoring
• Archive node access for game history
• WebSocket support for real-time updates

Pricing:

• Free: 50M credits
• Build: $49/mo (80M credits)
• Accelerate: $249/mo (450M credits)
• Scale: $499/mo (950M credits)
• Business: $999/mo (2B credits)

Cost Example: 100M gaming requests ≈ $250-500/mo depending on methods

Best For: Global gaming applications requiring consistent low latency worldwide.

4. Chainstack - Managed Gaming Infrastructure

Pricing: $49 to $990/month | Model: Request-based

Chainstack offers both shared and dedicated node options with extensive management tools—ideal for gaming studios that want infrastructure handled by experts.

Key Features:

• Dedicated Ronin nodes available
• Subgraph indexing for game data
• Analytics dashboard for monitoring
• Bolt (enhanced API) for performance
• 24/7 support for production games
• WebSocket support

Pricing:

• Developer: Free (3M requests)
• Growth: $49/mo (20M requests)
• Pro: $199/mo (80M requests)
• Business: $349/mo (140M requests)
• Enterprise: $990/mo (400M requests)

Cost Example: 100M requests = $349-990/mo (Business-Enterprise tier)

Best For: Gaming studios wanting managed infrastructure and dedicated support.

5. dRPC - Decentralized Gaming Infrastructure

Pricing: $299 to $1,796+/month | Model: Compute units

dRPC aggregates multiple node providers in a decentralized network for enhanced reliability—valuable for gaming applications that can't tolerate downtime during peak play sessions.

Key Features:

• Decentralized architecture for redundancy
• Auto-failover prevents gaming downtime
• Multiple providers for censorship resistance
• Geographic routing for optimal latency
• WebSocket support for real-time gaming

Pricing:

• Free: Public tier (rate limited)
• PAYG: $299/mo (1B CU)
• PAYG: $599/mo (2B CU)
• PAYG: $1,198/mo (4B CU)

Cost Example: 100M requests ≈ $300-600/mo depending on method distribution

Best For: Gaming projects prioritizing decentralization and maximum uptime.

6. GetBlock - Developer-Focused Gaming Tools

Pricing: $49 to $499+/month | Model: Compute units

GetBlock uses a Compute Units model that measures actual computational resources consumed—giving gaming developers flexibility in how they optimize their RPC usage.

Key Features:

• 50+ blockchains for multi-chain gaming
• Shared and dedicated nodes
• REST and WebSocket APIs
• Archive access for game history
• Flexible rate limits
• Method-specific pricing multipliers

Pricing:

• Free: Available with CU limits
• Starter: $49/mo (50M CU)
• Advanced: $199/mo (220M CU)
• Pro: $499/mo (600M CU)

Cost Example: 100M requests ≈ $200-400/mo (method-dependent)

Best For: Gaming developers seeking flexible compute-based pricing with multi-chain support.

7. NodeReal - Cost-Effective Gaming Scale

Pricing: $39 to $499+/month | Model: Compute units

NodeReal focuses on providing cost-effective infrastructure with strong performance—ideal for gaming studios scaling rapidly without breaking the budget.

Key Features:

• Enhanced APIs for gaming
• MetaScan analytics
• High throughput for peak gaming sessions
• Dedicated support options
• Archive data access

Pricing:

• Free: 25M CU/month
• Growth: $39/mo (500M CU)
• Team: $199/mo (2B CU)
• Business: $499/mo (5B CU)

Cost Example: 100M requests ≈ $40-200/mo (very cost-effective)

Best For: Budget-conscious gaming studios needing strong performance at scale.

8. Ankr - Multi-Chain Gaming Infrastructure

Pricing: $50 to $2,000+/month | Model: Compute units

Ankr specializes in multi-chain infrastructure—perfect for gaming studios building cross-chain games or operating on multiple blockchains simultaneously.

Key Features:

• 50+ blockchains supported
• Advanced caching layer reduces costs
• Premium endpoints for gaming
• RPC aggregation
• Token APIs for in-game assets

Pricing:

• Free: 500M CU/day (rate limited)
• PAYG: $50/mo (500M CU)
• PAYG: $200/mo (2B CU)
• PAYG: $500/mo (5B CU)
• PAYG: $1,000/mo (10B CU)

Cost Example: 100M requests ≈ $100-300/mo depending on usage

Best For: Multi-chain gaming applications needing cross-platform infrastructure.

9. BlockPI - Budget Gaming Infrastructure

Pricing: $49 to $299/month | Model: Compute units

BlockPI offers competitive pricing for gaming developers—especially attractive for indie studios and early-stage gaming projects watching their budgets.

Key Features:

• Multi-chain support
• Compute unit efficiency
• Standard RPC methods
• Archive data available
• WebSocket support

Pricing:

• Free: Available
• Elementary: $49/mo (500M CU)
• Premium: $299/mo (4B CU)

Cost Example: 100M requests ≈ $50-150/mo (very budget-friendly)

Best For: Indie gaming studios and early-stage projects with budget constraints.

10. Moralis - Gaming Web3 APIs

Pricing: $49 to custom | Model: Compute units

Moralis provides specialized Web3 gaming APIs alongside RPC access—valuable for gaming developers who need both infrastructure and gaming-specific tooling in one platform.

Key Features:

• Gaming-specific Web3 APIs
• NFT APIs for in-game assets
• Token balance tracking
• Enterprise-grade RPC nodes
• Free tier for development

Pricing:

• Free: 40K CU/day
• Starter: $49/mo
• Pro: $249/mo
• Business: Custom

Cost Example: Varies significantly based on API usage mix

Best For: Gaming developers needing both RPC infrastructure and Web3 gaming APIs.

Pricing Model Breakdown: Gaming Considerations

Understanding pricing models is essential for budgeting your gaming infrastructure costs.

Simple Pricing (Dwellir)

How it works: 1 request = 1 unit, regardless of method complexity

Gaming Advantages:

• Predictable monthly costs for budgeting
• Easy to calculate based on player counts
• No surprise bills during viral growth
• Simple scaling decisions

Example: 100M player actions = 100M credits at any tier

Compute Unit Pricing (Alchemy, QuickNode, Ankr, NodeReal, GetBlock, dRPC, BlockPI)

How it works: Each method has a multiplier based on computational resources

Common Gaming Method Costs:

Gaming Challenges:

Example: 100M gaming requests could cost 1B-5B+ CU depending on game mechanics

Real Cost Comparison: 100M Monthly Gaming Requests

Typical gaming mix (70% standard queries, 25% logs/events, 5% receipts):

Key Takeaway: Simple pricing (Dwellir) saves 30-60% for gaming at scale by eliminating method premiums and offering unlimited requests.

Key Selection Criteria for Gaming dApps

1. Latency Requirements

Fast-Paced Games (PvP, Action):

• Priority: Sub-100ms latency, WebSocket persistence
• Best Options: QuickNode, Dwellir, Alchemy

Turn-Based Games (Strategy, Card Games):

• Priority: Reliability over speed, cost efficiency
• Best Options: Dwellir, NodeReal, BlockPI

Metaverse/MMO:

• Priority: High throughput, WebSocket scaling, global performance
• Best Options: QuickNode, Alchemy, Dwellir

2. Budget Considerations

Indie Studios:

• Use free tiers during development
• Consider: BlockPI ($49), NodeReal ($39), Dwellir ($49)

Growing Gaming Studios (100K+ players):

• Need predictable costs and scaling
• Consider: Dwellir ($299), NodeReal ($199), Ankr ($200)

AAA Gaming Studios:

• Require SLAs and dedicated infrastructure
• Consider: Alchemy (enterprise), QuickNode (business), Chainstack (dedicated)

3. Multi-Chain Gaming Strategy

Building Across Multiple Chains?

• Best: Dwellir (150+ chains, one key)
• Good: Ankr (50+ chains), GetBlock (50+ chains)
• Limited: Ronin-specific providers

4. Gaming-Specific Features

NFT-Heavy Games (Play-to-Earn, Collectibles):

• Need: NFT APIs, metadata, token indexing
• Best: Alchemy, Moralis, QuickNode (with add-ons)

Real-Time Multiplayer:

• Need: WebSocket reliability, low latency
• Best: QuickNode, Dwellir, Alchemy

Analytics-Heavy Games:

• Need: Archive data, event indexing
• Best: Dwellir, Alchemy, Chainstack

Feature Comparison Matrix

Cost Optimization Strategies for Gaming

1. Cache Game State Data

Implement Redis/Memcached for:

• Player balances (cache for 6-12 seconds)
• Item metadata and NFT data
• Contract ABIs
• Leaderboard data

Savings: 40-60% reduction in RPC calls for typical games

2. Batch Read Operations

Use multicall contracts instead of individual calls:

// Instead of 100 individual balance checks
const balances = await Promise.all(
  players.map(addr => token.balanceOf(addr))
);

// Use multicall pattern
const balances = await multicall.aggregate(calls);

Savings: 80-95% fewer RPC calls for batch operations

3. Optimize WebSocket Subscriptions

Subscribe to relevant events only:

// Subscribe to game-relevant events
provider.on('block', (blockNumber) => {
  // Update game state
});

// Filter logs for your game contracts only
provider.on({
  address: gameContractAddress,
  topics: [eventTopic]
}, (log) => {
  // Handle game event
});

Savings: 90%+ reduction compared to polling for game events

4. Smart Archive Data Usage

• Query recent data from standard nodes
• Use archive nodes only for historical game data
• Cache historical queries aggressively
• Store game history in separate database

Savings: 50-70% on archive-dependent game features

5. Implement Read-Through Caching

Cache expensive calls at application layer:

async function getCachedPlayerData(address) {
  // Check cache first
  let data = await cache.get(`player:${address}`);
  if (!data) {
    // Fetch from blockchain
    data = await contract.getPlayerData(address);
    await cache.set(`player:${address}`, data, 30); // 30s TTL
  }
  return data;
}

Savings: 70-90% for frequently accessed game data

Ronin 2026 Upgrade: What Gaming Developers Need to Know

zkEVM Layer 2 Transition (Q1-Q2 2026)

Ronin is transitioning to an Ethereum Layer 2 using zkEVM technology. Here's what this means for RPC infrastructure:

Benefits:

• 12x faster transaction processing
• Lower transaction costs for players
• Enhanced Ethereum security
• Better composability with Ethereum DeFi

RPC Implications:

• New RPC endpoints for L2
• Potential changes to gas estimation
• Updated WebSocket subscription models
• Bridge contract interactions

Provider Readiness: All major providers (Dwellir, Alchemy, QuickNode, Chainstack) have confirmed they'll support the Ronin L2 upgrade immediately upon launch.

Migration Planning

Gaming studios should:

1. Test on testnet when L2 testnet launches (Q1 2026)
2. Monitor provider announcements for L2 support
3. Plan gas optimization for new L2 economics
4. Update SDKs to support L2 features
5. Communicate with players about upgrade benefits

Frequently Asked Questions

Do I need dedicated nodes for my game?

For most games: Shared RPC infrastructure (Dwellir, Alchemy, QuickNode) provides sufficient performance.

When you need dedicated:

• 1M+ daily active players
• High-frequency trading games
• Custom node configurations needed
• Regulatory compliance requirements

Providers offering dedicated nodes: Chainstack, QuickNode (business tier), Alchemy (enterprise)

How do I handle RPC downtime during gameplay?

Best practices for gaming:

1. Implement fallback providers:

const providers = [
  primaryProvider,    // Fastest/main
  secondaryProvider,  // Backup
  tertiaryProvider    // Emergency
];

2. Use provider with strong SLA (99.9%+ uptime)
3. Monitor provider health before sending requests
4. Queue transactions during brief outages
5. Show user-friendly errors instead of crashes

Can I switch providers without disrupting players?

Yes! RPC providers use standardized JSON-RPC interfaces. Switching requires only:

1. Update endpoint URL in config
2. Update API keys
3. Test WebSocket subscriptions
4. No game code changes needed

Zero-downtime migration: Run both providers simultaneously, gradually shift traffic.

What's the cost per player?

Typical costs per daily active player:

Example: 10,000 DAU playing an action game = ~15M requests/day = 450M/month = $49-299 depending on provider

Should I use public Ronin RPC endpoints?

No, not for production games. Public endpoints are:

• Rate limited (unsuitable for real games)
• Best-effort availability (no SLA)
• Shared with everyone (slow during peaks)
• Not suitable for WebSockets

Use public endpoints only for:

• Initial development
• Testing
• Proof-of-concept demos

Always use paid providers for production games to ensure player experience.

How do WebSockets work for real-time gaming?

WebSockets maintain persistent connections for instant updates:

Common gaming subscriptions:

Provider WebSocket support:

• All major providers support standard WebSocket subscriptions
• Alchemy offers enhanced subscriptions with filters
• Dwellir provides unlimited WebSocket connections on all paid plans

Gaming pattern:

const ws = new WebSocket(provider.wsUrl);

// Subscribe to game contract events
ws.send(JSON.stringify({
  jsonrpc: '2.0',
  id: 1,
  method: 'eth_subscribe',
  params: ['logs', {
    address: gameContractAddress,
    topics: [gameEventTopic]
  }]
}));

ws.onmessage = (event) => {
  // Update game state in real-time
  updateGameState(JSON.parse(event.data));
};

What about Sky Mavis shutting down Skynet?

Sky Mavis is sunsetting their Skynet services as part of Ronin's transition to a fully permissionless ecosystem. This means:

Developers must migrate from Sky Mavis endpoints to third-party RPC providers Timeline: Complete migration recommended before Q1 2026 Recommended providers: All providers in this guide are officially recommended alternatives

Migration is straightforward:

1. Choose provider from this guide
2. Sign up and get API key
3. Replace endpoint URL in your game
4. Test thoroughly before fully switching
5. Keep Sky Mavis as fallback during transition

Advanced Gaming Features Comparison

Real-Time Event Monitoring

Critical for games that react instantly to blockchain events:

WebSocket Performance:

Debug & Trace for Gaming

Essential for debugging game economics and anti-cheat systems:

Gaming use cases:

• debug_traceTransaction: Investigate failed player transactions
• trace_filter: Track token flows for economy balancing
• debug_traceBlockByNumber: Analyze game events in specific block

Archive Data for Game History

Archive nodes essential for:

• Historical player stats and achievements
• Tax/accounting for play-to-earn
• Game economy analytics over time
• Player history and progression tracking

Provider archive depth:

• Full archive: Dwellir, Alchemy, QuickNode, Chainstack (complete Ronin history)
• Partial archive: Some providers may limit depth
• No archive: Free tiers typically exclude archive access

Enterprise Gaming Considerations

Service Level Agreements for AAA Games

Dwellir: 99.99% uptime guarantee

• Proactive monitoring
• Response credits for downtime
• Incident reports and root cause analysis

Alchemy: 99.9% for enterprise plans

• Financial penalties for SLA breaches
• Dedicated account team
• Custom SLAs negotiable

QuickNode: 99.95% for business tier

• Uptime credits
• Priority support with Slack channel
• Multi-region redundancy

Support for Live Operations

Compliance & Security for Gaming

Data Privacy:

• Dwellir: Dedicated servers (not public cloud)
• Alchemy: SOC 2 Type II certified
• QuickNode: GDPR compliant
• Chainstack: ISO 27001 certified

Gaming-Specific Security:

• API key authentication (all providers)
• IP whitelisting (enterprise tiers)
• Rate limiting per API key
• DDoS protection (all major providers)
• Transaction simulation (prevents failed txns)

Choosing the Right Provider: Gaming Decision Framework

For Indie Game Studios

Priority: Minimal costs + reliable infrastructure + easy setup

Best Options:

1. NodeReal ($39/mo) - Most affordable scaling
2. BlockPI ($49/mo) - Budget-friendly with good performance
3. Dwellir ($49/mo) - Simple pricing + multi-chain

Recommendation: Start with free tier for development. Upgrade to NodeReal Growth ($39) or Dwellir Developer ($49) when launching.

For Mid-Size Gaming Studios

Priority: Predictable costs + reliability + scalability

Best Options:

1. Dwellir ($299/mo) - Best price/performance, unlimited requests
2. QuickNode ($249-499/mo) - Global performance for worldwide players
3. Alchemy ($199-499/mo) - Rich gaming features and APIs

Recommendation: Dwellir Growth ($299) for predictable gaming costs. QuickNode if global latency is critical.

For AAA Gaming Studios

Priority: SLAs + dedicated support + custom infrastructure

Best Options:

1. Alchemy (Enterprise) - Most comprehensive gaming platform
2. QuickNode (Business) - Best global performance + dedicated support
3. Chainstack (Enterprise) - Fully managed dedicated nodes
4. Dwellir (Scale+) - Cost-effective with 99.99% SLA

Recommendation: Evaluate based on specific needs. Alchemy for feature-rich platform, QuickNode for performance, Dwellir for cost optimization.

For Specific Gaming Genres

Play-to-Earn / NFT Games:

• Need: NFT APIs, token indexing, wallet tracking
• Best: Alchemy, Moralis, QuickNode (with NFT add-ons)

Real-Time PvP Games:

• Need: Ultra-low latency, WebSocket reliability
• Best: QuickNode, Dwellir, Alchemy

On-Chain Strategy Games:

• Need: Archive data, cost efficiency, reliability
• Best: Dwellir (no method premiums), NodeReal, Chainstack

Metaverse / Social Gaming:

• Need: High throughput, burst capacity, global reach
• Best: QuickNode, Alchemy, Dwellir

Multi-Chain Gaming Ecosystems:

• Need: One API key, consistent interface across chains
• Best: Dwellir (150+ chains), Ankr (50+ chains)

Conclusion: Best Ronin RPC Provider for Gaming in 2026

The best provider depends on your gaming priorities:

Best Overall Value: Dwellir

Winner for: Predictable costs, unlimited requests, multi-chain gaming

• Simplest pricing eliminates budget surprises
• 40-60% cheaper at scale than competitors
• No compute unit complexity
• 99.99% uptime SLA for always-on gaming
• 150+ blockchains for cross-platform games
• Cost: $49-999/mo for unlimited requests

Best for Features: Alchemy

Winner for: NFT-heavy games, comprehensive tooling, enterprise gaming

• Most extensive Web3 gaming platform
• Rich NFT and token APIs for play-to-earn
• Advanced analytics and player tracking
• Transaction simulation prevents failed txns
• Cost: $199/mo to custom enterprise

Best for Performance: QuickNode

Winner for: Global games, competitive PvP, low-latency requirements

• Fastest global network (30+ regions)
• Consistent < 50ms latency worldwide
• Excellent burst handling for viral games
• Cost: $249-999/mo

Best for Multi-Chain: Dwellir

Winner for: Cross-platform gaming, multi-chain ecosystems

• Single API key for 150+ blockchains
• Consistent pricing across all networks
• Simplified multi-chain development
• Cost: $49-999/mo

Final Recommendations

If you're launching your first game: Start with free tiers (Alchemy 300M CU, NodeReal 25M CU, Chainstack 3M requests) for development. Monitor actual usage patterns for 2-4 weeks.

If you're scaling to production: Dwellir offers the best price-performance ratio for most gaming applications. The simple 1:1 pricing eliminates billing surprises and scales predictably with player growth.

If you need gaming-specific features: Evaluate Alchemy (NFT APIs, gaming tooling), QuickNode (global performance), or Moralis (gaming APIs) based on your game's requirements.

If you're building cross-chain: Dwellir's 150+ network support with one API key provides the best developer experience and cost efficiency for multi-chain gaming.

For the Ronin L2 upgrade: All major providers will support the 2026 zkEVM transition. Choose your provider now and they'll handle the upgrade seamlessly.

Get Started with Ronin RPC

Test Before Committing

1. Sign up for free tiers at 2-3 providers
2. Run parallel testing for 1-2 weeks with real gameplay
3. Monitor latency, reliability, and projected costs
4. Choose based on actual gaming performance and player feedback

Calculate Your Gaming Costs

Estimate your monthly RPC bill:

1. Project player counts: Daily active users (DAU)
2. Estimate RPC calls per player: 50-10,000 depending on game type
3. Calculate monthly requests: DAU × calls/day × 30
4. Add growth buffer: 30-50% for viral growth
5. Compare providers: Use pricing calculators

Example calculation:

• 5,000 DAU playing a trading card game
• 300 RPC calls per player per day
• 5,000 × 300 × 30 = 45M requests/month
• With 50% growth buffer = 67M requests/month
• Dwellir cost: $49/mo (Developer plan, unlimited)
• NodeReal cost: $39-199/mo depending on method mix
• QuickNode cost: $49-249/mo depending on credits used

The right RPC provider becomes invisible infrastructure—reliable, fast, and affordable. Your players should never think about blockchain latency, only about winning the game. Choose wisely and your infrastructure becomes your competitive advantage.

Additional Resources

• Dwellir Platform
• Ronin Official Documentation
• Ronin 2026 L2 Upgrade Announcement
• Sky Mavis Developer Resources
• Ronin Block Explorer
• Ethereum JSON-RPC Specification

Last updated: December 2025. Pricing and features subject to change. Ronin L2 upgrade scheduled for Q1-Q2 2026.