---
name: Chainstack
description: Use when deploying blockchain nodes, managing RPC endpoints, querying blockchain data via JSON-RPC APIs, configuring multi-chain infrastructure, or building dApps that need reliable access to 70+ blockchain networks.
metadata:
    mintlify-proj: chainstack
    version: "1.0"
---

# Chainstack Skill

## Product summary

Chainstack is a managed blockchain node platform supporting 70+ chains (Ethereum, Solana, Polygon, Bitcoin, TON, Hyperliquid, and others). Agents use Chainstack to deploy RPC nodes, access blockchain data via JSON-RPC APIs, manage multi-chain infrastructure, and configure node endpoints for dApps. Key files: Platform API endpoints at `https://api.chainstack.com/v2/` and `v1/`; node endpoints use HTTPS or WSS protocols with key or password authentication. CLI: Use the Chainstack console at `https://console.chainstack.com/` to manage projects, networks, and nodes. Primary docs: https://docs.chainstack.com/

## When to use

Reach for this skill when:
- **Deploying blockchain nodes**: Creating RPC endpoints for Ethereum, Solana, Polygon, or other chains
- **Querying blockchain data**: Making JSON-RPC calls to read blocks, transactions, logs, account balances, or contract state
- **Managing infrastructure**: Creating projects, networks, and nodes; viewing credentials and metrics
- **Configuring multi-chain dApps**: Setting up endpoints for multiple blockchains in a single application
- **Automating node management**: Using the Platform API (v2 or v1) to programmatically create, update, or delete nodes
- **Monitoring usage**: Checking request metrics, quotas, and billing against subscription plans
- **Troubleshooting connectivity**: Diagnosing endpoint access, authentication, or rate-limit issues

## Quick reference

### Node endpoint formats

| Type | Format | Auth |
|------|--------|------|
| HTTPS (key) | `https://nd-123-456-789.p2pify.com/3c6e0b8a9c15224a8228b9a98ca1531d` | URL token |
| HTTPS (password) | `https://user:pass@nd-123-456-789.p2pify.com` | Basic auth |
| WSS (key) | `wss://ws-nd-123-456-789.p2pify.com/3c6e0b8a9c15224a8228b9a98ca1531d` | URL token |
| WSS (password) | `wss://user:pass@ws-nd-123-456-789.p2pify.com` | Basic auth |
| gRPC | `sui-mainnet.core.chainstack.com:443` | x-token header |

### Platform API authentication

```bash
curl -X GET 'https://api.chainstack.com/v2/projects/' \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

Create API keys in console at **Settings > API Keys**. Keys are shown once only—store securely.

### JSON-RPC call example

```bash
curl https://YOUR_ENDPOINT \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

### Subscription plans and quotas

| Plan | Quota | Pay-as-you-go | Use case |
|------|-------|---------------|----------|
| Free | Limited RUs | No | Testing, low-volume dApps |
| Growth | Medium RUs | Yes | Production dApps |
| Pro | High RUs | Yes | High-volume applications |
| Dedicated | Custom | Custom | Enterprise, guaranteed resources |

Request units (RUs): Full node = 1 RU, Archive node = 2 RUs. Check pricing page for protocol-specific costs.

### Node types and modes

| Type | Mode | Use case |
|------|------|----------|
| Elastic | Full | Standard queries, most dApps |
| Elastic | Archive | Historical state queries, block explorers |
| Dedicated | Full/Archive | Guaranteed resources, high throughput |
| Trader | N/A | Solana/Ethereum/BNB priority transactions |

## Decision guidance

### When to use Elastic vs Dedicated nodes

| Scenario | Elastic | Dedicated |
|----------|---------|-----------|
| Development/testing | ✓ | ✗ |
| Production, variable load | ✓ | ✗ |
| High-volume, predictable load | ✗ | ✓ |
| Need guaranteed uptime SLA | ✗ | ✓ |
| Cost-sensitive | ✓ | ✗ |
| Custom resource allocation | ✗ | ✓ |

### When to use Full vs Archive nodes

| Query type | Full | Archive |
|-----------|------|---------|
| Current block/balance | ✓ | ✓ |
| Recent transactions | ✓ | ✓ |
| Historical state (>128 blocks) | ✗ | ✓ |
| Block explorers | ✗ | ✓ |
| Backfill data | ✗ | ✓ |

### Platform API v1 vs v2

| Feature | v1 | v2 |
|---------|----|----|
| Manage projects | ✓ | ✓ |
| Manage nodes | ✓ | ✓ |
| Manage networks | ✓ | ✗ |
| Manage organizations | ✓ | ✗ |
| Manage faucets | ✓ | ✗ |
| List deployment options | ✗ | ✓ |
| Recommended for new work | ✗ | ✓ |

## Workflow

### Deploy a node and access it

1. **Create a project**: Log in to console, click "Create project", provide name and optional description.
2. **Add a network**: Click your project, then "Add network" or "Join network" for the blockchain you need.
3. **Deploy a node**: Click the network, then "Add node". Select protocol, network, node type (Elastic/Dedicated), and mode (Full/Archive). Enable Debug/Trace APIs if needed. Review and click "Create node".
4. **Wait for deployment**: Status changes from "Pending" to "Running" (typically 2–5 minutes).
5. **Retrieve credentials**: Click the node name. Copy the HTTPS or WSS endpoint and auth token/password.
6. **Test the endpoint**: Make a test JSON-RPC call using curl or your web3 library to verify connectivity.
7. **Monitor usage**: Return to the node page to view request metrics, method calls, and response codes.

### Programmatically create a node with Platform API v2

1. **Get your API key**: Go to console **Settings > API Keys**, create a new key, and copy it.
2. **List deployment options**: Call `GET /v2/deployment-options` to see available protocols and networks.
3. **Create a project**: Call `POST /v2/projects` with project name.
4. **Create a node**: Call `POST /v2/projects/{id}/nodes` with protocol, network, and node configuration.
5. **Poll for status**: Call `GET /v2/projects/{id}/nodes/{node_id}` until status is "Running".
6. **Extract endpoint**: Parse the response to get the node endpoint URL.

### Query blockchain data via JSON-RPC

1. **Identify the method**: Determine which JSON-RPC method you need (e.g., `eth_blockNumber`, `eth_getBalance`, `eth_getLogs`).
2. **Check method availability**: Verify the method is supported for your protocol and node type (some methods require Archive nodes or Debug/Trace APIs enabled).
3. **Construct the request**: Build a JSON-RPC 2.0 request with `jsonrpc`, `method`, `params`, and `id`.
4. **Send the request**: POST to your node endpoint with `Content-Type: application/json`.
5. **Handle the response**: Parse the JSON response. Check for `error` field; if present, handle the error (e.g., rate limit, invalid params).
6. **Implement retry logic**: On transient errors (5xx, timeouts), retry with exponential backoff.

### Monitor quota and billing

1. **Check current usage**: Go to console **Statistics** to view request volume and quota consumption.
2. **Review billing**: Go to **Settings > Billing** to see current balance, subscription plan, and pay-as-you-go status.
3. **Set alerts**: Enable email notifications (automatic at 80% and 100% quota usage).
4. **Adjust plan**: Upgrade subscription or enable pay-as-you-go if approaching quota limits.

## Common gotchas

- **API key exposure**: API keys are shown once. Store in environment variables (`.env` file), never commit to version control. Rotate keys regularly.
- **Endpoint authentication mismatch**: Ensure you use the correct auth method (key in URL vs basic auth). Mixing them causes 401 errors.
- **Archive node cost**: Archive nodes consume 2 RUs per request vs 1 RU for full nodes. Use only when querying historical state.
- **Block range limits**: `eth_getLogs` and similar methods have block range limits (typically 1000–10000 blocks). Paginate large queries.
- **Rate limits**: Exceeding plan limits triggers throttling (429 responses). Implement exponential backoff; don't retry immediately.
- **Inactive node deletion**: Nodes unused for 30 days are automatically deleted. Redeploy if needed.
- **Debug/Trace APIs overhead**: Enabling debug/trace APIs increases resource consumption. Enable only on nodes that need them.
- **WebSocket connection limits**: WSS endpoints have concurrent connection limits. Reuse connections; don't create new ones per request.
- **Stale data**: Full nodes may lag behind the chain tip by a few blocks. Use `eth_syncing` to check sync status.
- **Method not found errors**: Some methods (e.g., `eth_getBlockReceipts`) are client-specific (Erigon vs Geth). Check which client your node runs via `web3_clientVersion`.

## Verification checklist

Before submitting work with Chainstack:

- [ ] **Node deployed and running**: Verify status is "Running" in console, not "Pending" or "Failed".
- [ ] **Endpoint accessible**: Test with a simple JSON-RPC call (e.g., `eth_blockNumber`) and confirm 200 response.
- [ ] **Authentication correct**: Confirm endpoint uses correct auth method (key or password) and credentials are valid.
- [ ] **Quota sufficient**: Check remaining quota in **Statistics**; ensure plan covers expected request volume.
- [ ] **Correct node type**: Verify node type (Elastic/Dedicated) and mode (Full/Archive) match use case.
- [ ] **Debug/Trace APIs enabled** (if needed): Confirm enabled in node settings if using trace/debug methods.
- [ ] **Error handling implemented**: Confirm code handles rate limits (429), timeouts, and invalid responses.
- [ ] **Credentials not exposed**: Verify API keys and passwords are in environment variables, not hardcoded.
- [ ] **Monitoring in place**: Confirm metrics are being tracked and quota alerts are enabled.
- [ ] **Fallback endpoints configured**: For production, test failover to secondary endpoints or global nodes.

## Resources

**Comprehensive navigation**: https://docs.chainstack.com/llms.txt

**Critical pages**:
- [Platform Introduction](https://docs.chainstack.com/docs/platform-introduction) — Overview of Chainstack features and supported chains
- [Platform API Getting Started](https://docs.chainstack.com/reference/platform-api-getting-started) — How to create API keys and authenticate
- [Manage Your Nodes](https://docs.chainstack.com/docs/manage-your-node) — Deploy, access, and monitor nodes
- [Authentication Methods](https://docs.chainstack.com/docs/authentication-methods-for-different-scenarios) — API key, basic auth, and bearer token details
- [Pricing & Quotas](https://docs.chainstack.com/docs/pricing-introduction) — Subscription plans, request units, and billing
- [Best Practices for Error Handling](https://docs.chainstack.com/docs/best-practices-for-error-handling-in-api-requests) — Retry logic and reliability patterns

---

> For additional documentation and navigation, see: https://docs.chainstack.com/llms.txt