Site icon Chainstack

How to migrate from Grove to Chainstack (2026 guide)

Alex Usachev
Migrate From Grove 1 logo

Introduction

Grove — originally Pocket Network Inc., founded in 2017 by Michael O’Rourke, Valeria Benitez Florez, Pabel Nunez, and Luis Correa de Leon — has wound down after nine years. The Grove Portal settled more than a trillion requests across 60+ blockchains during its run. Now the rpc.grove.city and docs.grove.city domains no longer resolve, paid customers were migrated to the free Pocket Network Foundation endpoints at api.pocket.network starting November 2025, and in July 2026 Grove the company published its farewell note.

Two groups of teams are affected — and the fix looks slightly different depending on which one you’re in:

This guide is for teams in either bucket making the move to a dedicated RPC provider. It walks through the endpoint swap, the one code change you actually need (authentication), the chain mapping, and the validation you should do before decommissioning anything. The official Chainstack migration doc is the canonical reference; this article covers the same ground with the context and the trade-off calls Chainstack has run into with teams moving off Grove.

What actually happened

The grove.city site as of July 2026 — the farewell note that replaced the Grove Portal.

The Grove wind-down happened in two stages, and understanding which stage affected you changes what you need to do.

November 2025 — the gateway wind-down. Grove announced it was stepping away from operating the Grove Portal and moving up the stack. This came right after two protocol milestones: the Shannon upgrade shipped June 3, 2025, and PATH 1.0 — the reference gateway implementation — reached its milestone on November 4, 2025, enabling anyone to launch a permissionless Pocket gateway. Paid and public traffic migrated to new public endpoints hosted at api.pocket.network, managed by the Pocket Network Foundation with round-robin load balancing across PNF and community gateways (DevDAO Cloud, Pokt.ai, Stakenodes). The handoff was orderly — same JSON-RPC methods, same chain coverage, host swap only.

2026 — the pivot and the closure. Grove used the freed-up team to build a creator-payments platform on the x402 protocol, which ran for five months and settled ~6,000 payments from about 1,000 fans to 400 creators. In July 2026, the company published a farewell note and closed. The rpc.grove.city and docs.grove.city subdomains stopped resolving.

If your code still has rpc.grove.city URLs, you already know because your app is throwing DNS errors. If you followed the November redirect to api.pocket.network, your calls still work — Pocket Network itself continues under the PNF as a non-profit, and the Foundation runs the public endpoints as part of its F-Chains “public good” program with routing across 5,000+ independent supplier nodes. But you are now on shared, unmetered infrastructure with no dedicated capacity, no isolation, and no support contract. That is the exact reason most teams move to a paid provider even when the free path still resolves.

What migration actually looks like

For most Grove users, the migration is a one-line URL swap. Both Grove and Chainstack speak standard JSON-RPC over HTTPS. The methods and responses are identical. The one meaningful code change is authentication.

Grove endpoints were open. No key, or an optional app-id in the URL path (https://eth.rpc.grove.city/v1/YOUR_APP_ID). Anyone with the URL could call them. The current Pocket Foundation successor endpoints follow a similar open pattern with a chain subdomain (https://eth.api.pocket.network) — also key-free.

Chainstack endpoints authenticate every request. The default method is an auth token embedded directly in the endpoint URL. You copy the full HTTPS endpoint from the Chainstack console and use it as-is — no separate Authorization header, no query parameter to add, no code changes beyond the URL itself.

In practice:

// ethers.js — before (Grove, retired)
const provider = new ethers.JsonRpcProvider(
  "https://eth.rpc.grove.city/v1/YOUR_APP_ID"
);

// ethers.js — after (Chainstack)
const provider = new ethers.JsonRpcProvider(
  "YOUR_CHAINSTACK_ENDPOINT"
);

const block = await provider.getBlockNumber();
console.log(`Current block: ${block}`);

Same pattern in Python:

from web3 import Web3

# Before — Grove (retired)
# web3 = Web3(Web3.HTTPProvider("https://eth.rpc.grove.city/v1/YOUR_APP_ID"))

# After — Chainstack
web3 = Web3(Web3.HTTPProvider("YOUR_CHAINSTACK_ENDPOINT"))

print(f"Current block: {web3.eth.block_number}")

Non-EVM chains work the same way. On Solana, you point your client at the Chainstack Solana endpoint and keep calling the standard Solana JSON-RPC methods. On Sui or TRON — the pattern is identical, only the RPC surface changes.

If you need something other than URL-embedded auth — basic auth for infrastructure that can’t carry secrets in URLs, the Chainstack Platform API key for programmatic node management, or the gRPC x-token for streaming workloads — see Authentication methods. Most teams start with the default and never revisit it.

The fastest migration path: AI agent

Before the manual steps: if you use Claude Code, Codex CLI, Cursor, Windsurf, Gemini CLI, Antigravity, or any other agentic coding tool, the fastest migration is to let the agent do it. Chainstack publishes a runbook for exactly this. Paste the following into your agent and approve the plan it generates:

get docs.chainstack.com/docs/migrate-to-chainstack-with-ai.md
Pasting the one-liner into Claude Desktop fetches the Chainstack migration runbook — the agent then walks through Assess, Plan, and Implement phases.

The agent scans your codebase for Grove endpoints (and any other RPC URLs), checks coverage against Chainstack, plans the swap, and executes after you approve. It uses the Chainstack MCP server for live deployment options and pricing. Full details in the migrate to Chainstack with AI guide. The manual steps below are for teams that prefer to migrate by hand or want to understand what the agent is doing.

Chain mapping

Every chain Grove supported that Chainstack also supports maps directly. The subdomain in your Grove URL tells you what to look for:

Grove subdomainChainstack protocol
ethEthereum
baseBase
arb-oneArbitrum
opOptimism
polyPolygon
bscBNB Smart Chain
avaxAvalanche
gnosisGnosis Chain
lineaLinea
scrollScroll
sonicSonic
opbnbopBNB
harmonyHarmony
kaiaKaia (ex. Klaytn)
solanaSolana
suiSui
tronTRON

Chainstack supports 70+ chains total, so if you were on Grove for a subset of these, this is also a chance to consolidate other RPC infrastructure onto a single provider. The protocols and networks page is the authoritative current list.

Two edge cases worth flagging. If you were using Grove for a chain not on this table — some of the more experimental Cosmos SDK chains, or something added to Pocket recently — check the Chainstack list first; if it is not there, it may still be available as a dedicated deployment via Chainstack sales. And if your app was using an app-id-per-chain pattern on Grove (one Portal application, many chain endpoints), that maps to one Chainstack project with multiple nodes — same organizational shape, different terminology.

Picking your Chainstack node type

Grove Portal was effectively one product. Chainstack has four, and picking the right one is where teams either overthink or underthink the migration.

The right default for most Grove users is a Global Node (docs) — load-balanced, routes requests to the nearest healthy region, covers standard queries for standard workloads. This is the closest analog to what Grove Portal gave you: a URL, geographic redundancy behind it, no capacity planning required. Most Grove migrations land here.

You need a different node type when your workload has specific characteristics:

Start with a Global Node unless you have a clear reason not to. The other options are not upgrades — they are different, for specific workload shapes.

Migrating

The mechanics, in order:

1. Create a Chainstack account and deploy a node. Sign up with your GitHub, X, Google, or Microsoft account — no credit card required for the free tier. Create a project, then deploy a Global Node for the chain you are migrating first.

Deploying a new node — pick your protocol and network. Grove users migrating from eth.rpc.grove.city select Ethereum chain here.

2. Copy the endpoint. Open the node’s Access and credentials tab and copy the HTTPS endpoint. The auth token is already in the URL — no separate configuration needed.

The Access and credentials tab in the Chainstack console — the HTTPS endpoint already includes your auth token, no separate header configuration needed.

3. Swap the URL in your code. The cleanest way is via environment variables, if you are not already using them. Replace the Grove URL with the Chainstack endpoint:

# Before
ETH_RPC_URL=https://eth.rpc.grove.city/v1/YOUR_APP_ID
# After
ETH_RPC_URL=YOUR_CHAINSTACK_ENDPOINT

If you have hardcoded URLs in config files (hardhat.config.js, foundry.toml, Docker files), this is a good moment to move them to env vars while you are here. The next migration you do — provider or otherwise — will be minutes instead of hours.

4. Test the actual methods your code uses. Not just eth_blockNumber — the specific calls your application depends on. For a straightforward dApp that is standard reads and writes. For an indexer, archive queries and log range calls. For a trading bot, transaction submission latency under real conditions. The debug and trace APIs reference covers what’s available where.

curl -X POST \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  YOUR_CHAINSTACK_ENDPOINT

5. Run parallel for at least 24 hours before decommissioning anything. If you were on the free api.pocket.network endpoints, keep them as a fallback until you are confident. If you were on paid Grove that is now offline, this step is moot — you are already on the new endpoint by necessity. Chainstack’s dashboard shows request counts, error rates, and latency per node — monitor for the first day before turning off the old path.

What Chainstack adds that you did not have on Grove

Grove was a solid decentralized gateway with a clean developer experience. The switch to Chainstack adds a few things that only start to matter once you have real production traffic:

None of these matter for a hobby project. All of them start mattering the moment you have paying users or a business that depends on the read path staying up.

Common issues during migration

A few things that come up more often than they should:

IssueCauseFix
401 UnauthorizedYou added an Authorization header thinking Chainstack works like Grove-with-an-app-id. Chainstack embeds the auth token in the URL, not a header.Remove the Authorization header and copy the full endpoint URL from the node access details page.
Archive queries returning errorsYou are hitting a Global Node without archive access.Upgrade to a plan with archive support, or deploy a Dedicated Node in archive mode for the chain you need. See features availability for per-plan coverage.
debug_traceTransaction not supportedDebug and trace on Global Nodes require a paid plan. Free Developer tier does not expose these methods.Upgrade to at least Growth if your prototype depends on debug_* or trace_* namespaces.
WebSocket disconnectsLong-lived connections drop occasionally on every provider — not Chainstack-specific.Add reconnect logic with exponential backoff to your WSS client. Standard practice regardless of provider.
Method not found on SolanaSome Solana methods require specific node configurations (Trader Node, Yellowstone gRPC, or specific plan).Search the Chainstack docs for the exact method name to confirm required node type.

When Chainstack is not the right answer

A few honest cases where the migration is not a straightforward win:

Conclusion

Nine years, more than a trillion requests, an orderly two-stage wind-down. The Grove closure was as clean as these things get in Web3 — a documented handoff to Pocket Network Foundation endpoints, months of transition, and a clear final note. Most teams affected have already made a move. The remaining decision is whether the api.pocket.network free endpoints are enough for your workload, or whether you want dedicated capacity, higher throughput, archive access, and support.

The Chainstack migration itself is one line. Copy the endpoint from the console, swap the URL in your code, run a validation pass, and decommission the old configuration. If you use an AI coding agent — Claude Code, Codex, Cursor, Windsurf — the migrate to Chainstack with AI runbook does the endpoint discovery and swap for you.

Create a free Chainstack account →

FAQ

Do my Grove endpoints still work?

rpc.grove.city endpoints stopped resolving in July 2026 when Grove closed. If your code still points at them, calls are failing with DNS errors. api.pocket.network public endpoints continue to work under the Pocket Network Foundation, but they are free, shared, and load-balanced across community gateways with no SLA.

How long does the migration take?

For a straightforward URL swap, most teams complete the code change in under an hour and validate over the next day or two. If you use an AI coding agent to discover and swap endpoints, the code change is minutes; the validation window is the same.

Do I need to change my JSON-RPC method calls?

No. Grove and Chainstack both expose standard JSON-RPC. Every method your Grove code called works on Chainstack with the same signature and response format. The only code difference is authentication, and that is handled entirely by the URL.

What happens to my existing Grove authentication (app-id in URL path)?

Chainstack’s auth token is already embedded in the endpoint URL you copy from the console — same URL-in-path pattern, different token format. Remove the Grove app-id from your URLs and replace the entire endpoint with the Chainstack one.

Which chain node type should I pick?

Global Node for most workloads — load-balanced, geo-routed, closest analog to Grove Portal. Dedicated Node if you need isolation, guaranteed capacity, or the full debug/trace namespace. Trader Node if you are running latency-sensitive trading workloads. Unlimited Node add-on if you want a flat monthly fee at a fixed RPS tier instead of per-request accounting.

Is Pocket Network the same as Grove?

No. Pocket Network is the underlying decentralized RPC protocol, run by the Pocket Network Foundation. Grove was the first gateway built on top of it, operated by a separate company (originally Pocket Network Inc., renamed Grove). The protocol continues; the gateway is retired. Free api.pocket.network endpoints are run directly by the Foundation.

Can I keep using free Pocket Network endpoints alongside Chainstack?

Yes. Some teams keep api.pocket.network as a fallback path for non-critical reads while running production traffic through Chainstack. On EVM chains, eRPC or a similar client-side router can split traffic by method or fail over between the two. For non-EVM chains, you would need to handle the fallback in application code.

Canonical references

Other migration guides

Pocket Network / Grove background

Exit mobile version