Getblock

Skill based on GetBlock docs, generated 2026-02-09. Source: https://github.com/GetBlock-io/getblock-docs

GetBlock provides plug-and-play node and API access for 100+ chains (Ethereum, BNB Chain, Polygon, Solana, TON, etc.). Authentication is via access token in the endpoint URL; no headers. Shared nodes use Compute Units (CU) for billing; dedicated nodes have custom limits.

Core References

Features

Integration

External Links

• GetBlock docs
• GetBlock nodes / pricing
• Compute Units

Generation Info

• Source: sources/getblock (https://github.com/GetBlock-io/getblock-docs)
• Git SHA: 16d0a2e9ca57767495ad931a8b06d37add91949e
• Generated: 2026-02-09
• Docs used: README.md, getting-started/ (authentication, endpoints, plans, testing), guides/ (ethers, curl, MCP), api-reference/overview.md, add-ons/yellowstone-grpc-api/overview.md

GetBlock Authentication

Authentication is done via an access token embedded in the endpoint URL. Tokens are not sent in headers.

Endpoint format

https://go.getblock.io/<ACCESS_TOKEN>/

Region-specific hosts: go.getblock.io (EU/Frankfurt), go.getblock.us (New York), go.getblock.asia (Singapore). The token in the path authenticates the request; the client does not specify chain in the URL.

Making a request

Use the full endpoint URL (including token) as the request target. Example — fetch latest Ethereum block number:

curl --location --request POST 'https://go.getblock.io/<ACCESS_TOKEN>/' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": "getblock.io"
  }'

Security

• Store access tokens securely; avoid exposing them in repos or logs.
• If a token is compromised: Dashboard → locate the endpoint → three-dot menu → roll (regenerate) or delete the token. Rolling does not disrupt other endpoints.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• getting-started/authentication-with-access-tokens.md

-->

GetBlock Compute Units (CU)

Shared node plans use Compute Units (CU) to measure and price API usage. One request can cost multiple CUs depending on chain and method.

Formula

Total CU = Chain Multiplier × Method Multiplier

• Chain multiplier: Reflects network resource intensity (e.g. Ethereum 20, Solana/Sui/TON 50, Bitcoin 10).
• Method multiplier: Light methods (e.g. eth_blockNumber) = 1; heavy methods (e.g. trace_replayBlockTransactions, archive/trace) have higher multipliers.

Example: debug_traceTransaction on Ethereum = 20 × 2 = 40 CU.

Why it matters for agents

• Prefer light methods when only block number or single tx is needed; avoid trace/replay when not required.
• Archive and trace calls consume more CUs; use when necessary for historical state or debugging.
• CU balance is shared across all shared-node endpoints; track usage on the dashboard.

Plans (summary)

Free: 50k CU/day, 20 RPS, 2 tokens. Paid tiers: higher CU/month, RPS, and token limits. Dedicated nodes are not CU-limited. See GetBlock pricing page for exact plan table.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• getting-started/plans-and-limits/what-counts-as-a-cu.md
• getting-started/plans-and-limits/cu-and-rate-limits.md

-->

GetBlock Endpoints

Endpoints are created in the GetBlock Dashboard. Each endpoint URL includes a unique access token and encodes protocol, network, and routing.

Creating an endpoint

1. Dashboard → Endpoints → Get endpoint. 2. Select: protocol (Ethereum, BNB Chain, Polygon, etc.), network (mainnet/testnet), mode (full or archive), API (JSON-RPC, WebSockets, GraphQL, etc.), region (Frankfurt, New York, Singapore). 3. Click Get to generate the endpoint URL with access token.

Example URL forms:

• EU: https://go.getblock.io/<ACCESS_TOKEN>/
• US: https://go.getblock.us/<ACCESS_TOKEN>/
• Asia: https://go.getblock.asia/<ACCESS_TOKEN>/

Full vs archive mode

• Full: Standard full (pruned) node — current state, send tx, read blocks.
• Archive: Historical chain state — past balances, contract storage, historical calls, simulation at a past block. Archive usage is billed differently (see CU/pricing docs).

Managing endpoints

Endpoints appear in the dashboard list. Use the right-side menu (three dots) to roll (regenerate token) or delete the endpoint. The URL is the credential; keep it secret; if exposed, regenerate or revoke from the account.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• getting-started/endpoint-setup/creating-node-endpoints.md

-->

GetBlock API Overview

GetBlock provides node and API access for 100+ blockchains (EVM and non-EVM, L1/L2). Agents can assume standard RPC interfaces; the main integration task is endpoint URL and authentication.

Interfaces

• JSON-RPC (HTTP and WebSocket)
• GraphQL, REST where supported per chain
• Endpoint is created per protocol/network/API type in the dashboard; one URL per combination.

Node types

• Shared nodes: CU-based limits, multiple tokens per plan; suitable for most apps and scripts.
• Dedicated nodes: No CU/RPS limits; custom plans.

Add-ons and extended APIs

• Yellowstone Geyser (gRPC): Solana real-time streaming (accounts, transactions, slots). See features-yellowstone-grpc.md.
• DAS API, Firehose, Blockbook: Documented in GetBlock add-ons; use when the app needs those specific APIs.

Full node list and method specs: GetBlock API Reference and nodes/pricing pages.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• api-reference/overview.md
• README.md

-->

GetBlock with Ethers.js

Use GetBlock as the RPC provider for Ethers.js (Ethereum and EVM-compatible chains).

Setup

const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://go.getblock.io/<ACCESS_TOKEN>');

const blockNumber = await provider.getBlockNumber();
console.log('Latest Block Number:', blockNumber);

Replace <ACCESS_TOKEN> with the token from your GetBlock endpoint URL. Use the same endpoint for all provider calls (read, send, contract interaction). For viem or other libraries, pass the same GetBlock URL as the transport RPC URL.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• guides/using-web3-libraries/ethers.js-integration.md

-->

Testing GetBlock with cURL

Use POST requests with JSON-RPC payloads to the GetBlock endpoint URL (token in path). Content-Type: application/json.

Block number

curl --location --request POST 'https://go.getblock.io/<ACCESS_TOKEN>/' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": "getblock.io"
  }'

Response result is hex block number (e.g. "0x1449641").

Chain ID

curl ... --data-raw '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":"getblock.io"}'

e.g. 0x1 = Ethereum mainnet.

Account balance

curl ... --data-raw '{
  "jsonrpc":"2.0",
  "method":"eth_getBalance",
  "params":["<ACCOUNT_ADDRESS>","latest"],
  "id":"getblock.io"
}'

Result is balance in wei (hex). Replace <ACCESS_TOKEN> and <ACCOUNT_ADDRESS> with real values. For full method list and examples, use GetBlock API Reference.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• getting-started/testing-rpc-connection/using-curl-for-testing.md
• api-reference/overview.md

-->

MCP Server with GetBlock

Model Context Protocol (MCP) lets AI assistants call external tools. A minimal MCP server can expose GetBlock Ethereum RPC as tools (e.g. balance, gas price, block number).

Pattern

1. Get a GetBlock access token (Ethereum JSON-RPC endpoint). 2. Implement an MCP server that:

• Exposes tools such as get_eth_balance(address), get_gas_price(), get_block_number().
• Each tool issues a JSON-RPC request to https://go.getblock.io/<ACCESS_TOKEN>/ (e.g. eth_getBalance, eth_gasPrice, eth_blockNumber).

3. Configure Claude (or other MCP client) to use this server so the assistant can query chain data via GetBlock.

Stack example

Node.js, @modelcontextprotocol/sdk, ethers or raw fetch: create provider with GetBlock URL, then implement MCP tool handlers that call the provider and return results. Validate inputs (e.g. address format) with Zod or similar before calling RPC.

This gives agents a standardized way to read Ethereum state through GetBlock without hardcoding RPC logic in the model.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• guides/basic-level-model-context-protocol-with-getblock-api-endpoints.md

-->

GetBlock Yellowstone gRPC (Solana)

Yellowstone gRPC is a Solana Geyser plugin that streams on-chain data with low latency. GetBlock exposes it for Solana applications that need real-time updates (e.g. indexers, MEV, live dashboards).

Capabilities

• Streams: Account updates, transactions, blocks, slot notifications.
• Filtering: By account key, owner program, data patterns, commitment.
• Unary RPCs: Slot, block height, latest blockhash, valid blockhash on demand.

Data is pushed as it happens (often faster than standard RPC/WebSocket finality). gRPC is backend-only; not for browser clients.

When to use

• Need continuous Solana account/tx/block updates without polling.
• Building indexers, arbitrage bots, or real-time analytics that react to chain events immediately.

Setup and connection details (endpoint, auth) are in GetBlock dashboard under Solana / Yellowstone Geyser add-on. Use the same access-token-in-URL pattern where applicable, or dedicated gRPC credentials as documented by GetBlock.

<!-- Source references:

• https://github.com/GetBlock-io/getblock-docs
• add-ons/yellowstone-grpc-api/overview.md
• guides/listening-to-high-value-sol-transactions-via-yellowstone-geyser-grpc-with-getblock.md

-->