---
name: chainstack
description: Use when deploying blockchain RPC nodes, querying blockchain data, managing infrastructure across 70+ networks, or building Web3 applications. Reach for this skill when agents need to provision nodes, authenticate to endpoints, call blockchain APIs, or manage Chainstack resources programmatically.
metadata:
    mintlify-proj: chainstack
    version: "1.0"
---

# Chainstack Skill

## Product summary

Chainstack is a blockchain infrastructure platform providing managed RPC node access to 70+ blockchain networks (Ethereum, Solana, Polygon, Bitcoin, etc.). Deploy a node in seconds from the console, get an endpoint URL, and call it immediately—or run the same stack on your own Kubernetes cluster with Chainstack Self-Hosted. Agents use Chainstack to provision nodes, authenticate to endpoints, call blockchain JSON-RPC methods, and manage infrastructure programmatically via the Chainstack Platform API.

**Key files and endpoints:**
- Console: https://console.chainstack.com/
- Platform API: https://api.chainstack.com/v1/
- Node endpoints: `https://<network>.core.chainstack.com/<AUTH_TOKEN>` or `wss://ws-<network>.core.chainstack.com/ws/<AUTH_TOKEN>`
- Faucet API: https://faucet.chainstack.com/
- MCP server: https://mcp.chainstack.com/mcp

**Primary docs:** https://docs.chainstack.com/

## When to use

Deploy this skill when:
- An agent needs to create, configure, or delete blockchain nodes across multiple networks
- Building a Web3 application that requires RPC access to one or more blockchains
- Querying blockchain data (blocks, transactions, account balances, logs, smart contract state)
- Monitoring real-time blockchain events via WebSocket subscriptions
- Requesting testnet funds from the Chainstack faucet
- Managing node credentials, endpoints, and access rules
- Benchmarking or troubleshooting RPC endpoint performance
- Migrating from another blockchain infrastructure provider
- Implementing authentication for blockchain API requests
- Analyzing request usage and billing across projects

## Quick reference

### Node types

| Type | Use case | Deployment | Archive support |
|------|----------|-----------|-----------------|
| **Global Node** | General-purpose, worldwide access, auto-failover | Seconds | Full node only |
| **Unlimited Node** | High-throughput, sustained workloads, no RPS limits | Minutes | Full + archive |
| **Trader Node** | MEV-aware, priority transaction propagation | 3-6 min | Full + archive |
| **Dedicated Node** | Custom resources, debug/trace APIs, isolated | Minutes | Full + archive |

### Authentication methods

| Method | Use case | Security | Example |
|--------|----------|----------|---------|
| **URL auth token** | Simple, stateless requests | Medium | `https://eth-mainnet.core.chainstack.com/YOUR_TOKEN` |
| **Basic auth** | Username/password, header-based | Medium (over HTTPS) | `-u username:password` |
| **gRPC x-token** | gRPC endpoints (Solana, Sui, TRON) | Medium | Pass `x-token` in metadata |
| **Platform API key** | Managing nodes/projects programmatically | High | `Authorization: Bearer YOUR_API_KEY` |

### Common RPC methods by category

**Blocks & transactions:**
- `eth_blockNumber` — latest block number
- `eth_getBlockByNumber` — block data by number
- `eth_getTransactionByHash` — transaction details
- `eth_getTransactionReceipt` — transaction receipt with logs

**Account data:**
- `eth_getBalance` — account balance
- `eth_getCode` — smart contract bytecode
- `eth_getStorageAt` — contract storage slot
- `eth_getTransactionCount` — nonce for account

**Execution & simulation:**
- `eth_call` — read-only contract call
- `eth_estimateGas` — estimate gas for transaction
- `eth_simulateV1` — simulate transaction without sending
- `eth_sendRawTransaction` — broadcast signed transaction

**Events & logs:**
- `eth_getLogs` — query event logs with filters
- `eth_newFilter` — create persistent filter
- `eth_subscribe` (WebSocket) — stream new blocks, logs, pending transactions

**Gas & fees:**
- `eth_gasPrice` — current base gas price
- `eth_maxPriorityFeePerGas` — priority fee for EIP-1559
- `eth_feeHistory` — historical fee data

### Request units (RU) pricing

- **Full node request:** 1 RU (standard queries, calls, logs)
- **Archive request:** 2 RU (historical state, old blocks)
- Chainstack bills by RU consumed, not raw call count
- See pricing page for plan quotas and extra usage costs

### Endpoint formats

```
HTTPS (key auth):
https://ethereum-mainnet.core.chainstack.com/YOUR_AUTH_TOKEN

HTTPS (basic auth):
https://username:password@ethereum-mainnet.core.chainstack.com

WebSocket (key auth):
wss://ws-ethereum-mainnet.core.chainstack.com/ws/YOUR_AUTH_TOKEN

WebSocket (basic auth):
wss://username:password@ws-ethereum-mainnet.core.chainstack.com/ws

gRPC (x-token):
ethereum-mainnet.core.chainstack.com:443
(pass x-token in metadata)
```

## Decision guidance

### When to use Global Node vs Dedicated Node

| Scenario | Global Node | Dedicated Node |
|----------|------------|----------------|
| General dApp, variable traffic | ✓ | — |
| High-throughput, sustained load | — | ✓ |
| Need debug/trace APIs | — | ✓ |
| Cost-sensitive, shared resources OK | ✓ | — |
| Custom resource allocation | — | ✓ |
| Worldwide latency optimization | ✓ | — |

### When to use HTTP vs WebSocket

| Use case | HTTP | WebSocket |
|----------|------|-----------|
| One-off queries (balance, block) | ✓ | — |
| Polling for updates (inefficient) | ✓ | — |
| Real-time event streaming | — | ✓ |
| Monitoring logs/pending transactions | — | ✓ |
| Batch requests | ✓ | — |
| Persistent subscriptions | — | ✓ |

### When to use URL auth vs basic auth

| Scenario | URL auth | Basic auth |
|----------|----------|-----------|
| Simple scripts, one-off calls | ✓ | — |
| Infrastructure with header support | — | ✓ |
| Rotating credentials frequently | — | ✓ |
| Embedding in URLs (avoid) | — | ✓ |
| Maximum simplicity | ✓ | — |

## Workflow

### 1. Deploy a node and get an endpoint

1. Sign up at https://console.chainstack.com/ (GitHub, X, Google, or Microsoft account)
2. Create a project (or use existing)
3. Add a network (e.g., Ethereum Mainnet)
4. Add a node (select type: Global, Unlimited, Trader, or Dedicated)
5. Wait for status to change from **Pending** to **Running**
6. Click the node name to view credentials:
   - HTTPS endpoint (key-protected or password-protected)
   - WebSocket endpoint
   - gRPC endpoint (if available for protocol)
7. Copy the endpoint and auth token/credentials

### 2. Make your first RPC call

```bash
# Using curl with key auth
curl -X POST "https://ethereum-mainnet.core.chainstack.com/YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Using curl with basic auth
curl -X POST \
  -u username:password \
  -H 'Content-Type: application/json' \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  https://ethereum-mainnet.core.chainstack.com
```

### 3. Connect a Web3 library

```javascript
// ethers.js
const ethers = require('ethers');
const provider = new ethers.JsonRpcProvider('https://ethereum-mainnet.core.chainstack.com/YOUR_TOKEN');
const balance = await provider.getBalance('0x...');

// web3.js
const Web3 = require('web3');
const web3 = new Web3('https://ethereum-mainnet.core.chainstack.com/YOUR_TOKEN');
const balance = await web3.eth.getBalance('0x...');

// web3.py
from web3 import Web3
w3 = Web3(Web3.HTTPProvider('https://ethereum-mainnet.core.chainstack.com/YOUR_TOKEN'))
balance = w3.eth.get_balance('0x...')
```

### 4. Subscribe to real-time events (WebSocket)

```javascript
const WebSocket = require('ws');
const ws = new WebSocket('wss://ws-ethereum-mainnet.core.chainstack.com/ws/YOUR_TOKEN');

ws.on('open', () => {
  // Subscribe to new block headers
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['newHeads'],
    id: 1
  }));
});

ws.on('message', (data) => {
  const msg = JSON.parse(data);
  console.log('New block:', msg.params.result.number);
});
```

### 5. Manage nodes programmatically (Platform API)

```bash
# Create API key in console, then use it
curl -X GET https://api.chainstack.com/v1/organization/ \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Accept: application/json'

# List all projects
curl -X GET https://api.chainstack.com/v1/projects \
  -H 'Authorization: Bearer YOUR_API_KEY'

# Create a new node
curl -X POST https://api.chainstack.com/v1/projects/PROJECT_ID/nodes \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  --data '{
    "network": "ethereum-mainnet",
    "nodeType": "global"
  }'
```

### 6. Request testnet funds

```bash
# Via Chainstack Faucet API
curl -X POST https://faucet.chainstack.com/request \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  --data '{
    "network": "ethereum-sepolia",
    "address": "0x..."
  }'

# Or use the Chainstack MCP server from your editor
```

## Common gotchas

- **Exposing credentials:** Never commit API keys, tokens, or passwords to git. Use environment variables or secrets management. Rotate credentials regularly.
- **Block range too large:** Querying `eth_getLogs` over a huge block range causes timeouts. Keep ranges under 5,000 blocks; paginate if needed.
- **Confusing full vs archive requests:** Archive requests (querying old state) cost 2 RU; full requests cost 1 RU. Dedicated Nodes support both; Global Nodes are full-node only.
- **Missing WebSocket for subscriptions:** HTTP endpoints don't support `eth_subscribe`. Use WSS endpoints for real-time events.
- **Not handling rate limits:** Hitting RPS limits returns 429. Implement exponential backoff and respect plan limits (see Throughput guidelines).
- **Forgetting to enable extra usage:** If you exceed quota, extra usage is disabled by default. Enable it in Billing settings to avoid service interruption.
- **Using wrong endpoint format:** Mixing auth styles (e.g., token in URL + basic auth header) causes 401. Pick one method per request.
- **Ignoring error codes:** 400 = bad JSON-RPC, 401 = wrong credentials, 413 = payload too large, 429 = rate limit, 504 = timeout. Retry 5xx errors; fix 4xx errors.
- **Not batching requests:** Sending 100 individual HTTP requests is slower than one batch request. Use JSON-RPC batch for multiple calls.
- **Assuming all methods are available:** Debug/trace APIs, Warp transactions, and some advanced methods require Dedicated Nodes or specific add-ons. Check method availability for your node type.

## Verification checklist

Before submitting work with Chainstack:

- [ ] Node is in **Running** state (not Pending, Syncing, or Failed)
- [ ] Endpoint URL is correct (matches network and auth method)
- [ ] Credentials (token, username, password) are not exposed in code or logs
- [ ] RPC method is supported on the target network (check method reference)
- [ ] For WebSocket subscriptions, using WSS endpoint, not HTTPS
- [ ] Request payload is valid JSON-RPC 2.0 format
- [ ] Block ranges for `eth_getLogs` are reasonable (< 5,000 blocks)
- [ ] Error handling includes retry logic for 5xx errors
- [ ] Quota usage is monitored; extra usage is enabled if needed
- [ ] For gRPC, x-token is passed in metadata, not URL
- [ ] For Platform API calls, using Bearer token in Authorization header
- [ ] Node type matches workload (Global for general, Dedicated for high-throughput)

## Resources

**Comprehensive navigation:**
- [llms.txt](https://docs.chainstack.com/llms.txt) — compact index of all docs sections
- [llms-full.txt](https://docs.chainstack.com/llms-full.txt) — entire portal as plain text

**Critical pages:**
1. [Platform introduction](https://docs.chainstack.com/docs/platform-introduction) — overview of Chainstack products, node types, and getting started
2. [Blockchain APIs reference](https://docs.chainstack.com/reference/blockchain-apis) — JSON-RPC methods for all supported networks
3. [Authentication methods](https://docs.chainstack.com/docs/authentication-methods-for-different-scenarios) — detailed guide to API key, basic auth, and gRPC authentication
4. [Manage your node](https://docs.chainstack.com/docs/manage-your-node) — view credentials, monitor metrics, delete nodes
5. [Error reference](https://docs.chainstack.com/docs/error-reference) — HTTP status codes and RPC error handling
6. [Best practices](https://docs.chainstack.com/docs/chainstack-web3-development-best-practices) — performance, security, and reliability patterns
7. [Pricing & request units](https://docs.chainstack.com/docs/pricing-introduction) — billing, quotas, and plan comparison
8. [Platform API](https://docs.chainstack.com/reference/platform-api-getting-started) — programmatic node and project management

---

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