---
name: Chainstack
description: Use when deploying blockchain nodes, managing RPC endpoints, accessing blockchain APIs, configuring node infrastructure, or building Web3 applications that need reliable blockchain access across 70+ networks.
metadata:
    mintlify-proj: chainstack
    version: "1.0"
---

# Chainstack Skill

## Product summary

Chainstack is a managed blockchain infrastructure platform supporting 70+ blockchain networks. It provides RPC node endpoints, blockchain APIs, and deployment options for developers building Web3 applications. Agents use Chainstack to deploy nodes, manage projects and networks, access blockchain data via JSON-RPC, and configure infrastructure. Key resources: **Chainstack Console** (https://console.chainstack.com) for UI management, **Platform API** (v1 and v2) for programmatic infrastructure management, **Node endpoints** (HTTPS, WSS, gRPC) for blockchain access, and **API keys** for authentication. Primary docs: https://docs.chainstack.com

## When to use

Reach for this skill when:

- **Deploying blockchain nodes** — User needs to set up nodes for specific chains (Ethereum, Solana, Polygon, etc.) or wants to understand node types (Global, Unlimited, Trader, Dedicated)
- **Managing RPC endpoints** — User needs endpoint credentials, wants to configure access rules, or needs to switch between authentication methods
- **Building Web3 applications** — User is querying blockchain data via JSON-RPC, needs WebSocket subscriptions, or requires gRPC endpoints
- **Infrastructure automation** — User wants to programmatically create/delete projects, networks, or nodes via the Platform API
- **Troubleshooting blockchain access** — User has connection issues, authentication problems, or needs to understand rate limits and quotas
- **Configuring security** — User needs to set IP allowlists, domain restrictions, or manage API keys
- **Choosing node types** — User is deciding between Global Node (instant, load-balanced), Unlimited Node (high throughput), Trader Node (low latency), or Dedicated Node (custom resources)

## Quick reference

### Node types and use cases

| Node Type | Deployment | Latency | Throughput | Best for |
|-----------|-----------|---------|-----------|----------|
| Global Node | Seconds | Low (geo-routed) | High | Production dApps, global reach |
| Unlimited Node | Minutes | Medium | Very high | High-volume queries, indexing |
| Trader Node | 3-6 min | Very low | Medium | Trading bots, MEV-sensitive apps |
| Dedicated Node | Custom | Custom | Custom | Enterprise, custom requirements |

### Authentication methods for blockchain requests

| Method | Format | Use case | Security |
|--------|--------|----------|----------|
| URL-embedded key | `https://endpoint.com/YOUR_AUTH_TOKEN` | Simple, stateless | Medium |
| Basic auth | `-u username:password` | Legacy systems, simple | Medium (use HTTPS) |
| gRPC x-token | Metadata header `x-token: YOUR_TOKEN` | gRPC endpoints (Sui, Solana, TRON) | Medium |
| Platform API bearer | `Authorization: Bearer YOUR_API_KEY` | Infrastructure management | High |

### Platform API endpoints

```
Base URL: https://api.chainstack.com
v2 (recommended): /v2/projects, /v2/nodes, /v2/deployment-options
v1 (legacy): /v1/organization, /v1/projects, /v1/networks, /v1/nodes
```

### Common RPC request structure

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

### Pricing model

- **Request Units (RU)** — Primary billing metric; cost varies by method and network
- **Dedicated nodes** — Hourly compute + storage (alternative to per-request billing)
- **Add-ons** — MEV protection, Yellowstone Geyser, Warp transactions (separate charges)
- **Extra usage** — Overage charges if quota exceeded (configurable)

## Decision guidance

### When to use Global Node vs Unlimited Node vs Trader Node

| Scenario | Choose |
|----------|--------|
| Need instant deployment, global users, load balancing | Global Node |
| High request volume, batch processing, indexing | Unlimited Node |
| Trading bots, MEV-sensitive, low-latency critical | Trader Node |
| Custom resources, dedicated infrastructure, SLA | Dedicated Node |

### When to use URL-embedded key vs basic auth

| Scenario | Choose |
|----------|--------|
| Simple scripts, curl commands, stateless | URL-embedded key |
| Legacy systems, multiple endpoints, team access | Basic auth |
| gRPC endpoints (Sui, Solana, TRON) | x-token in metadata |
| Infrastructure API calls | Bearer token (Platform API) |

### When to use Platform API v1 vs v2

| Task | Use |
|------|-----|
| Create/manage projects and nodes | v2 (recommended) |
| List deployment options | v2 |
| Manage organizations, faucets | v1 |
| Legacy integrations | v1 |

## Workflow

### Typical task: Deploy a node and access blockchain data

1. **Create API key** — Go to Chainstack Console > Settings > API keys > Create key. Copy and store securely.

2. **Create project** — Console > Create project > Name it > Create. Projects organize networks and nodes.

3. **Add network** — Click project > Get started > Select blockchain (Ethereum, Solana, etc.) > Select network (mainnet, testnet).

4. **Deploy node** — Select node type (Global, Unlimited, Trader, Dedicated) > Configure options (archive, debug APIs if paid plan) > Deploy. Status changes from Pending to Running.

5. **Get endpoint credentials** — Click node name > View access information. Copy HTTPS endpoint, WSS endpoint, or gRPC endpoint + x-token.

6. **Test connection** — Use curl or Postman to make a test RPC call:
   ```bash
   curl -X POST "https://your-endpoint.com/YOUR_AUTH_TOKEN" \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
   ```

7. **Configure security** (optional) — Click node > Security > Add access rules (IP allowlist or domain allowlist).

8. **Monitor usage** — Click node > Metrics > View requests, method calls, response codes over time.

9. **Integrate into application** — Use endpoint in Web3 library (ethers.js, web3.js, web3.py, etc.).

### Typical task: Manage infrastructure via Platform API

1. **Authenticate** — Include `Authorization: Bearer YOUR_API_KEY` header in all requests.

2. **List projects** — `GET /v2/projects` to see existing projects.

3. **Create project** — `POST /v2/projects` with name and description.

4. **List deployment options** — `GET /v2/deployment-options` to see available node types and networks.

5. **Create node** — `POST /v2/nodes` with project ID, network, and node configuration.

6. **Monitor node** — `GET /v2/nodes/{node_id}` to check status, endpoint, credentials.

7. **Delete node** — `DELETE /v2/nodes/{node_id}` when no longer needed.

## Common gotchas

- **API key exposure** — API keys shown only once. Store securely; never commit to version control. Use environment variables.
- **Authentication method mismatch** — Blockchain requests use URL-embedded key or basic auth, NOT bearer tokens. Platform API uses bearer tokens. Don't mix them up.
- **gRPC x-token in URL** — gRPC endpoints require x-token in request metadata, not in URL. Passing it in URL will fail.
- **Access rules blocking requests** — If access rules are configured, requests not matching any rule are rejected. Ensure your IP or domain is in the allowlist.
- **Quota exceeded silently** — If extra usage is disabled and quota is exceeded, requests may fail. Check billing settings and enable extra usage if needed.
- **Node deletion cascades** — Deleting a node is permanent. Deleting all nodes in a network allows network deletion. Deleting all networks allows project deletion.
- **Archive nodes on free plan** — Archive nodes and debug/trace APIs only available on paid plans. Free plan limited to standard nodes.
- **WebSocket connection limits** — WebSocket subscriptions have per-connection limits. Use connection pooling for high-volume subscriptions.
- **Endpoint latency varies by node type** — Global Nodes have geo-routing overhead. Trader Nodes optimized for low latency. Choose based on use case.
- **Request unit costs vary by method** — Some RPC methods (e.g., `eth_getLogs` with large ranges) cost more RUs. Batch requests to optimize.

## Verification checklist

Before submitting work with Chainstack:

- [ ] API key created and stored securely (not in code)
- [ ] Project created and named appropriately
- [ ] Network selected matches intended blockchain (mainnet vs testnet)
- [ ] Node type chosen matches use case (Global for production, Trader for trading, etc.)
- [ ] Node status is "Running" (not Pending or Failed)
- [ ] Endpoint credentials copied correctly (HTTPS, WSS, or gRPC)
- [ ] Authentication method matches endpoint type (URL key vs basic auth vs x-token)
- [ ] Test RPC call succeeds with correct response
- [ ] Access rules configured if needed (IP/domain allowlist)
- [ ] Billing settings reviewed (quota, extra usage enabled if needed)
- [ ] Endpoint integrated into application code
- [ ] No sensitive credentials in logs or error messages

## Resources

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

**Critical documentation:**
- [Platform Introduction & Overview](https://docs.chainstack.com/docs/platform-introduction) — Start here for product overview
- [Authentication Methods](https://docs.chainstack.com/docs/authentication-methods-for-different-scenarios) — Detailed guide to all auth approaches
- [Platform API Getting Started](https://docs.chainstack.com/reference/platform-api-getting-started) — How to create API keys and make infrastructure calls
- [Manage Your Node](https://docs.chainstack.com/docs/manage-your-node) — View credentials, monitor metrics, configure access rules
- [Node Types & Configurations](https://docs.chainstack.com/docs/protocols-configurations) — Understand Global, Unlimited, Trader, Dedicated nodes
- [Pricing & Request Units](https://docs.chainstack.com/docs/pricing-introduction) — Understand billing model and quotas

---

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