Migrate your Stable RPC to Chainstack

Stable launched in late 2025 as an EVM-compatible Layer 1 built by the team behind USDT0, where dollars — not a volatile gas token — are the unit of account for every transaction. Chainstack shipped Stable Mainnet support on August 5, 2026 — Global Nodes, Full and Archive, with the debug_* namespace enabled on archive from day one.

Infra cost is one of the first blockers for a new team shipping on Stable. Since Chainstack added Stable Mainnet support in August, teams have been quietly moving their Stable RPC over to cut that cost. This guide is the reason to do the same, and the two ways to actually do it: paste one line into any AI coding agent, or migrate manually. First 3 months at 50% off Growth with code STABLE50.

Stable in two minutes

Stable is an EVM-compatible Layer 1 built by the team behind USDT0, purpose-designed so that gas is paid in USDT0 instead of a volatile native token. It runs on StableBFT, a CometBFT/Tendermint proof-of-stake consensus with block times around 0.7 seconds, and reached roughly $557M market cap with ~6,000 holders within weeks of mainnet. Chain ID is 988.

• Block time: ~0.7 seconds — roughly 17× more blocks per day than Ethereum’s ~12-second average
• Gas paid natively in USDT0 (18 decimals) — a separate asset from the USDT0 ERC-20 token (6 decimals)
• Private, always-empty public mempool — no pending-transaction subscriptions
• ~$557M market cap, ~6,000 holders within weeks of its late-2025 mainnet launch

The economically interesting part is the design: a chain where the unit of account is a dollar-pegged stablecoin, not a volatile gas token, built specifically for payments, settlement, and dollar-denominated onchain applications. That makes RPC correctness — not raw speed — the thing that actually matters for a production integration.

Why RPC budgets are getting rebalanced right now

A 0.7-second block chain changes your polling math whether you notice or not. An indexer that polled every block on Ethereum burned ~7,200 requests per day. The same indexer on Stable burns roughly ~123,000 — about 17× more. If your provider prices per compute unit or per method with a multiplier, this is where the bill quietly ships.

Stable also ships three behaviors that will surprise teams porting Ethereum tooling directly, each with real cost or correctness implications:

• The decimal trap. Native USDT0 gas reports 18 decimals; the USDT0 ERC-20 token (contract 0x779Ded0c9e1022225f8E0630b35a9b54bE713736) reports 6. Mixing them up is a 10^12 error.
• No public mempool. Pending-transaction subscriptions return nothing. Inbound-payment detection has to move to eth_subscribe log watching on the USDT0 contract instead.
• No Parity-style trace. trace_* methods return -32601. Tracing goes through the debug_* namespace (debug_traceTransaction, debug_traceBlockByNumber with callTracer) on an archive node instead.

Here’s how the field looks today. Stable’s own RPC providers documentation lists Alchemy and Tenderly alongside Chainstack; Quicknode, Uniblock, and OnFinality don’t yet support Stable.

Provider	Mainnet access	Archive & debug	Compliance	Pricing model
Chainstack	✅ Self-serve Global Nodes	✅ debug_* on archive	SOC 2 Type II, ISO 27001	RU-based; flat-fee Unlimited Node option
Tenderly	✅ Self-serve mainnet RPC	Simulation & tracing (its specialty)	SOC 2 Type II	Credit/unit-based
Alchemy	⚠️ Testnet public; mainnet enterprise-gated on request	Enhanced APIs	SOC 2 Type II	CU-based, method-weighted

Two structural points compound for a Stable migration specifically:

1. Mainnet access, not just support. Alchemy lists Stable, but production mainnet access is enterprise-gated on request rather than self-serve — a team prototyping on its public testnet can’t simply flip to a public mainnet endpoint the way they can on Ethereum. Chainstack and Tenderly both offer self-serve mainnet from day one.

2. Continuous reconciliation load punishes per-request billing. A stablecoin backend runs constant eth_getLogs sweeps and balance checks for reconciliation, not occasional bursts. CU-based and credit-based pricing (Alchemy, Tenderly) scales with that volume; Chainstack’s RU model plus the Unlimited Node add-on (flat monthly RPS tiers, $149/mo for 25 RPS up to $3,199/mo for 500 RPS) turns that into a fixed line instead of a bill that scales with transaction volume.

Chainstack also holds audited SOC 2 Type II and ISO 27001 certifications and offers Self-Hosted deployment for both Stable Mainnet and Testnet, for teams that need the node inside their own infrastructure perimeter. No public real-time benchmark dashboard covers Stable RPC providers yet — measure latency yourself from your target region before committing.

How to migrate: two paths

Path 1: One paste into any AI coding agent

Chainstack’s migration runbook is executable. Paste this into Claude Code, Cursor, Codex CLI, Windsurf, Gemini CLI, or any MCP-compatible agent:

get docs.chainstack.com/docs/migrate-to-chainstack-with-ai.md

The agent fetches the Migrate to Chainstack with AI runbook and walks through Assess → Plan → Implement:

• Assess. Scans the codebase for RPC endpoints, identifies protocol and method usage, and checks Chainstack coverage via the Chainstack MCP server. For teams already on Alchemy, it asks for your usage numbers from the Alchemy dashboard. Then it converts source usage to Chainstack Request Units and produces a live cost comparison.
• Plan. Lays out endpoint-by-endpoint replacement — which existing Chainstack node covers what, or what new nodes need to be created. Flags anything requiring manual console setup.
• Implement. After you approve the plan, the agent creates nodes via create_node and swaps endpoint URLs across your codebase. Summarizes what changed.

For most teams this is minutes, not weeks. The agent stops at the Plan step and waits for explicit approval before touching anything.

Path 2: Manual migration

If you prefer to run the migration yourself, the steps are direct. Timing depends on your codebase — a simple app takes an afternoon; a production workload with multiple services and monitored parallel operation takes a couple of days.

1. Inventory. Search the codebase, environment files, config, and secrets manager for RPC URLs pointing at your current provider. Note any code that relies on pending-transaction subscriptions (Stable’s mempool is always empty — this needs to move to eth_subscribe log watching) or Parity-style trace_* calls (these return errors on Stable; the replacement is the debug_* namespace).
2. Estimate. Pull your current RPC usage: the Alchemy dashboard, Tenderly’s usage page, or the billing page for other providers. Match your monthly request volume against Chainstack pricing and pick the cheapest plan that covers your volume, or the Unlimited Node add-on if your load is continuous reconciliation traffic.
3. Sign up. Create an account at console.chainstack.com. Apply STABLE50 at checkout for 50% off Growth, first 3 months.
4. Deploy. In the console: Add node → Stable → pick Mainnet (managed Global Nodes) — Testnet is currently available via Self-Hosted only. Dedicated Nodes aren’t supported for Stable yet. For reconciliation and audit-trail work, deploy an archive node; a full node is enough for real-time payment detection and submission.
5. Swap. Copy the HTTPS and WebSocket endpoints from Access and credentials and replace your existing RPC URLs. Keep the old provider live during transition as fallback.
6. Smoke test. Verify chain ID 988, then check both of USDT0’s decimal formats before anything else: formatEther() for the native 18-decimal gas balance, formatUnits(value, 6) for the ERC-20 token. Confirm eth_getLogs against the USDT0 contract picks up a known transfer, and run a debug_traceTransaction on a known transaction if you rely on trace.
7. Monitor. Compare error rates and latency (especially p95/p99, not just average) against your previous provider for the first 24–48 hours. No public benchmark dashboard covers Stable providers yet, so this comparison has to be your own.
8. Cut over. Once verified, remove the old provider from the config and revoke the API keys.

Both paths land you in the same place. Pick AI-agent if the codebase is complex or the team is small. Pick manual if you want end-to-end control over the sequence.

Deploy and claim your 50% off

• Promo code: STABLE50
• What it covers: 50% off the Growth plan — $49/month standard, $24.50/month for 3 months with the code
• Included: 20M requests/month, 250 RPS, Full and Archive nodes on Mainnet, WebSocket, debug_* methods
• Larger workloads: Business, Enterprise, or Dedicated deployments get a sales-led custom deal — contact the Chainstack team directly

Two-click redemption:

• Claim 50% off → — sign up or log in, code applies at checkout
• Migration guide → — full AI-agent runbook and manual reference

Who’s already building on Chainstack for Stable

Stable’s provider ecosystem is still forming since its late-2025 launch, but the migration pattern is already visible — tens of teams are running production RPC on Chainstack for Stable today, drawn by the combination of self-serve mainnet archive access, audited compliance, and flat-fee throughput options that the rest of the field doesn’t fully match yet. Chainstack is listed in Stable’s own RPC providers documentation and on the Stable ecosystem page.

FAQs

Additional resources

• Build with Stable on Chainstack — product page and discount CTA
• Chainstack introduces Stable Mainnet support — launch announcement with full coverage details
• Stable tooling documentation — SDKs, code examples, the decimal trap in detail
• Stable methods documentation — full JSON-RPC method reference and Stable-specific behavior
• Migrate to Chainstack with AI — AI-agent migration runbook
• Chainstack MCP server — full tool reference
• Chainstack pricing — plans, RU model, calculator
• Stable testnet faucet — free testnet funds for development