Access the dashboard

Once you've created an account and signed in, you'll be directed to the GetBlock Dashboard. Here, you can create endpoints, monitor your usage plan, and access statistics.

Check your User ID

Find your user ID located in the ‘Account Settings’ section or simply click your account icon to view it. Please use it when contacting GetBlock’s team so we can identify your account and help you faster.

With our tools and services, you can focus on building your Web3 project without worrying about the technical details of setting up and managing blockchain nodes.

From DeFi apps and NFT platforms to analytics tools, AppChains, and more, GetBlock provides the infrastructure to help you build, test, and scale your blockchain-powered solutions.

Core GetBlock features

• Plug-and-Play access

  Our ready-to-use blockchain nodes and APIs help you get started immediately.

• 99.9% uptime Reliable 24/7 connection to multiple blockchain networks.

• Multi-chain support

  Connect to Bitcoin, Ethereum, BNB Chain, Polygon, Solana, TON, and 50+ other networks. (And we support new protocols before anyone else!)

• Flexible plans

  From free access to enterprise-grade solutions, we’ve got options for every stage of your project.

• Custom solutions

  Need something unique? We can build tailored solutions for your specific blockchain needs.

• 24/7 Expert support

  Our team is here to help with integrations, troubleshooting, and scaling.

Discover GetBlock

Popular chains

Get started with our most in-demand blockchain networks.

GetBlock Product Demo

Here you'll find step-by-step instructions on how to integrate popular developer libraries like Web3.js, Ethers.js, and others with GetBlock API.

These libraries allow developers to interact with Ethereum and other EVM-compatible blockchains to read data, send transactions, and deploy smart contracts.

The guide covers setting up your connection to GetBlock and performing basic operations.

Every you create is assigned a unique access token:

The <ACCESS_TOKEN> authenticates requests directly through the endpoint URL.

Making an authenticated request

To make a request, include your full endpoint URL with the access token in the path.

For example, here’s how to fetch the latest Ethereum block number:

Response:

Access Token security

Always store your access tokens securely. Avoid exposing them in publicly accessible code repositories or logs.

If a token is compromised, you can quickly roll or delete it without disrupting other endpoints:

1. Go to your GetBlock Dashboard.

2. Locate the endpoint associated with the token.

3. Click the three-dot icon () next to the endpoint.

4. Select the option to either roll (regenerate) or delete the token.

This authentication method ensures that all your interactions with GetBlock’s services remain secure, reliable, and easy to manage.

Parameters

database - string

database name

key - string

key name

string - string

string to store.

Request

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

Response

{
    "result": "null",
    "id": "getblock.io",
    "status_code": 405,
    "message": "Method not allowed"
}

Parameters

-

Request

curl --location --request GET 'https://go.getblock.io/<ACCESS-TOKEN>/v1/estimate_gas_price' \
--header 'Content-Type: application/json'

Response

{
    "deprioritized_gas_estimate": 100,
    "gas_estimate": 100,
    "prioritized_gas_estimate": 150
}

Parameters

limit -

Maximum number of resources to retrieve. Gets default page size if not provided.

ledger_version -

Ledger version. Defaults to latest if not provided.

start -

Optional cursor specifying pagination start. You can call this endpoint once without this parameter, and then use the cursor returned in the X-Aptos-Cursor header in the response.

Request

curl --location --request GET 'https://go.getblock.io/<ACCESS-TOKEN>/v1/accounts/0xc20ea5a196c81d8d7aff814aa37f8a5823acffbc4193efd3b2aafc9ef2803255/modules?limit=10' \
--header 'Content-Type: application/json'

Response

[]

Parameters

-

Request

curl --location --request GET 'https://go.getblock.io/<ACCESS-TOKEN>/v1/transactions/by_hash/0x0137b99014705df2077763263f170ebef40fc88006d09da3b9139a32d761b554' \
--header 'Content-Type: application/json'

Response

{
    "accumulator_root_hash": "0xb1a0103f04d8ef3a942f80f04d231e559ae9f2d2b5b1f04be510d64c1d0f1a8d",
    "changes": [],
    "event_root_hash": "0x414343554d554c41544f525f504c414345484f4c4445525f4841534800000000",
    "gas_used": "0",
    "hash": "0x0137b99014705df2077763263f170ebef40fc88006d09da3b9139a32d761b554",
    "state_change_hash": "0xafb6e14fe47d850fd0a7395bcfb997ffacf4715e0f895cc162c218e4a7564bc6",
    "state_checkpoint_hash": "0x4d1b411db4f596d3d5a44da27d165a89d2b2589cc56dac00e2d9430aa7999555",
    "success": true,
    "timestamp": "1685066477483995",
    "type": "state_checkpoint_transaction",
    "version": "147832590",
    "vm_status": "Executed successfully"
}

Parameters

-

Request

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

Response

{
    "result": "null",
    "id": "getblock.io",
    "status_code": 405,
    "message": "Method not allowed"
}

Parameters

DATA - string

hash of the block.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x5"
}

Parameters

Object - object

Filter options

Request

curl --location --request POST 'https://go.getblock.io/YOUR-ACCESS-TOKEN' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_newFilter", "params": [{"fromBlock": "earliest", "toBlock": "latest", "topics": []}], "id": "getblock.io"}'

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x7a624b4e4688bb09c14e858427d9ede5"
}

Parameters

type - string

A subscription type, such as newHeads (new headers appended to the chain, including chain reorganizations), logs (logs that are included in new imported blocks and match the given filter criteria) or newPendingTransactions (hashes for all transactions that are added to the pending state and are signed with a key that is available in the node).

objects - hex string

Optional arguments such as an address, multiple addresses, and topics.

Request

wscat -c wss://go.getblock.io/ACCESS-TOKEN/ -x '{
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "params": ["newHeads", null],
  "id": "getblock.io"
}'

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0xe5af64ddfd365b4632988c5935cfedb7"
}

Parameters

id - string

the filter id.

Request

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

Response

{
    "result": "null",
    "id": "getblock.io",
    "status_code": 405,
    "message": "Method not allowed"
}

Generate and add as many access tokens as required for this protocol. Each token is a unique endpoint for you and your application to interact with the blockchain.

Viewing and managing access tokens

• To see all the access tokens generated for a specific protocol, simply expand the endpoint.

• Each protocol has a configuration file that includes all relevant access token details.

• The All Access Tokens Configuration file is located next to the My Endpoints section. Use it to review and manage your tokens.

To create a dedicated node endpoint, switch over to the ‘Dedicated Nodes’ tab in the Dashboard.

Select a blockchain protocol you wish to deploy and the network type. Click Get to begin the setup process. In the setup window:

1. Review and confirm your selected protocol and network.

2. Select a subscription plan (available discounts are applied automatically).

3. Customize your dedicated node with the following options:

   1. Node type: Choose between Full Node or Archive Node.

   2. Node client: Specify your preferred node implementation.

   3. API Interface: Select API options.

4. Verify all selected configurations in the summary section and proceed to checkout.

Pay for your dedicated nodes via your GetBlock account. If additional support is required during setup, you can contact the GetBlock support team directly.

You can add more dedicated nodes following these steps. Add as many access tokens for each dedicated node as you need.

Before you start:

1. Create a JSON-RPC endpoint for the Ethereum blockchain from your GetBlock account.

2. Replace <ACCESS_TOKEN> in the examples below with your actual Access Token.

Fetch the current block number

Run the following command to retrieve the latest block number:

If successful, the response will include the current block number in hexadecimal value:

Get the chain ID

Identify the blockchain network with the eth_chainId method:

Response example:

In this example, 0x1 indicates the Ethereum Mainnet. The chain ID helps confirm which blockchain network you are interacting with.

Check account balance by address

Retrieve the balance of an Ethereum address using eth_getBalance. Replace <ACCOUNT_ADDRESS> with the target wallet address:

Example response:

The result field shows the account balance in wei (1 ether = 10¹⁸ wei).

Import the collection into your Postman workspace: .

1. Once the page loads, you'll find a 'Run in Postman' button in the top-right corner. Click this button to open the collection directly in your Postman application.

2. Select the desired network from the drop-down list on the sidebar.

3. Paste the access token copied from your account instead of {YOUR_ACCESS_TOKEN}.

This token will grant you the necessary permissions to explore our node functionalities.

Web3.js is a JavaScript library built for interacting with the Ethereum blockchain and other EVM-compatible chains. It is used to send JSON-RPC calls to the Ethereum node via HTTP, IPC, or WebSocket connection to read data from the blockchain, make transactions, or deploy smart contracts.

Install Web3.js

Use your preferred package manager:

• npm:

• yarn:

• Pure js link:

Set up your connection to GetBlock

For additional methods and options, refer to the official .

The current CU balance for Shared Node users is displayed on the Dashboard. This shows how many Compute Units (CUs) are left before running out.

With the "Top Up" feature, users can add more Compute Units to their account or upgrade to higher monthly limits.

Add Compute Units: Paid plan users

Starter, Pro & Enterprise users can refill their CU balance or switch to another plan for increased limits:

1. Click the "Top Up" button on the Dashboard.

2. Select the number of CUs you’d like to add or choose the recommended plan (if prompted) based on your usage needs.

3. Confirm and finalize your purchase.

Your account balance will be updated immediately upon successful payment.

Increase CU limits: Free plan users

Free plan users cannot top up their Compute Units directly. Instead, you have the option to upgrade to one of our monthly paid plans, providing significantly higher limits and extra features.

Boost CU, RPS, and Access Token limits

If you're on the Enterprise plan (our customizable Shared Node plan), you can additionally request higher RPS and Access Token limits. Here’s how:

1. Click "Change" on the Dashboard next to the Rate Limit section.

1. Fill out and submit a request form, choosing your desired RPS limit, CU amount, and number of Access Tokens.

1. Our team will review your request and reach out to you with next steps shortly.

TronWeb is a JavaScript library of TRON full node’s API functions that is used to deploy smart contracts, query blockchain and contract information, trade on the decentralized exchanges and change the blockchain state.

Firstly, you will need to add the TronWeb library to your project.

• Npm:

• Yarn:

In your javascript file, define TronWeb:

When you instantiate TronWeb you can define:

• fullNode

• solidityNode

• eventServer

• privateKey

you can also set a

• fullHost

Which works as a jolly. If you do so, though, the more precise specification has priority. Supposing you are using a server which provides everything, like TronGrid, you can instantiate TronWeb as:

For retro-compatibility, though, you can continue to use the old approach, where any parameter is passed separately (using the GetBlock node as an example here):

After this you can call any TronWeb method:

All API references can be found in the project documentation at

Method response:

Parameters

module_name -

A type of struct to retrieve.

ledger_version -

Ledger version. Defaults to latest if not provided.

Request

Response

In blockchains, ‘account’ should be referred to as a pair of private and public keys. Blockchains ‘recognize’ their users and balances by these keypairs.

Unlike login/password pairs in traditional computational solutions, in modern blockchains, every account can be restored with a private key only.

So, to broadcast transactions to a decentralized network, we need first to create (or restore) our account. The whole set of interactions is organized via Web3.js library.

Creating accounts

First, initialize the Web3.js library and set up the connection to a blockchain node:

Next, we can create an account on the testnet:

We can also restore an account from an existing private key:

You may ask what does ‘eth’ mean when we’re interacting with BNB Chain? No mistake, it reflects the fact that BNB Smart Chain is fully compatible with Ethereum Virtual Machine.

Sending transactions

In blockchains, transactions should be signed (authorized) to be ‘included’ into blockchains (confirmed by its consensus of miners or validators).

Here’s how our transactions are created. 0.01 ETH is used for demo.

That’s how the transaction looks before being included in the blockchain. Once signed, it can be sent to the network of nodes.

That’s it: your account is good to go and its transaction is submitted successfully!

Parameters

-

Request

Response

Parameters

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

QUANTITY - string

the uncle’s index position.

Request

Response

Parameters

resource_type -

A type of struct to retrieve.

ledger_version -

Ledger version. Defaults to latest if not provided.

Request

Response

Parameters

database - string

Database name

key - string

key name

Request

Response

Parameters

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Boolean - Boolean

If true it returns the full transaction objects, if false only the hashes of the transactions.

Request

Response

Parameters

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

Response

Parameters

database - string

database name

key - string

key name

Request

Response

Parameters

DATA - string

address to check for balance.

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

Response

Parameters

-

Request

Response

Parameters

DATA - string

address.

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

Response

Parameters

id - string

the filter id.

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

filters - json object

filter object: { "to": "address" (string, optional) - Identity of the receiver. When present it will try to decrypt any incoming message if the client holds the private key to this identity. "topics": ["topic"] (array of string) - Array of topics which the incoming message’s topics should match. }

Request

Response

Parameters

-

Request

Response

Parameters

DATA - string

The signed transaction data.

Request

Response

Parameters

address - data

The identity address to add to a group

Request

Response

Parameters

limit -

Maximum number of events to retrieve. Gets default page size if not provided.

start -

Optional starting sequence number of events. Defaults to the most recent events.

Request

Response

Parameters

-

Request

Response

Parameters

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

QUANTITY - integer

Transaction index position.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": {
        "blockHash": "0x187ccf13bc440afc7fb146abf0642d4d6c02c438ea067f49f133566eef8627eb",
        "blockNumber": "0x5bc407a",
        "chainId": "0xa4b1",
        "from": "0x00000000000000000000000000000000000a4b05",
        "gas": "0x0",
        "gasPrice": "0x0",
        "hash": "0x7144169eeaff9b4b9d0a1948fa6149784710e3f55da837f93201fcfb0a6c2450",
        "input": "0x6bf6a42d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010924a40000000000000000000000000000000000000000000000000000000005bc407a0000000000000000000000000000000000000000000000000000000000000001",
        "nonce": "0x0",
        "r": "0x0",
        "s": "0x0",
        "to": "0x00000000000000000000000000000000000a4b05",
        "transactionIndex": "0x0",
        "type": "0x6a",
        "v": "0x0",
        "value": "0x0"
    }
}

Ethers.js is a lightweight JavaScript library for interacting with Ethereum and other EVM-compatible blockchains. It is commonly used by developers to build decentralized applications (dApps) and manage Ethereum-based operations like deploying smart contracts, interacting with them, and managing user wallets.

Install Ethers.js

Add Ethers.js to your project using your preferred package manager:

• npm

npm install ethers

• yarn

yarn add ethers

Set GetBlock as a provider

// Import the Ethers library
const { ethers } = require('ethers');

// Set up the provider (replace ACCESS_TOKEN with your actual token)
const provider = new ethers.JsonRpcProvider('https://go.getblock.io/ACCESS_TOKEN');

//Call a method using the provider
const main = async () => {
  const blockNumber = await provider.getBlockNumber();
  console.log("Latest Block Number:", blockNumber);
};

// Call the main function
main();

For further details and advanced usage, explore the Ethers.js documentation.

Parameters

DATA - string

hash of the block.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x0"
}

Parameters

DATA - string

Hash of a transaction.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": {
        "blockHash": "0xd8fe755134d44967f0c919084d3e0ec9b875c476c924f37bff17e5ef37d10d47",
        "blockNumber": "0x5911313",
        "chainId": "0xa4b1",
        "from": "0xe911f7f98ac57cf0c1cc71519d3ba720089381c4",
        "gas": "0x1a02b0",
        "gasPrice": "0x1dcd6500",
        "hash": "0xfd11ef35c7179439723e026cb7857ea5a2e48a19257bec00b0ed26672f632181",
        "input": "0x1801fbe5d5843b1d8c7345812c7ba7257e927b0c5e000000a6ca46b71aa1cdb6545660ad000000004f62e6aa5433274e333035ca261c12397df9febee0782f42749b8e0b",
        "nonce": "0x3c",
        "r": "0x87ac24f33be39a0bd27fe84a8934aa957610872606e5dbc46d296843a57930df",
        "s": "0x6ad9aba71382c20a528f3310c369b095e15991b352aea3261e2683c2b1288964",
        "to": "0xae56c981f9bb8b07e380b209fcd1498c5876fd4c",
        "transactionIndex": "0x1",
        "type": "0x0",
        "v": "0x14986",
        "value": "0x0"
    }
}

Parameters

object - json object

The transacion call object in format: { "from": "address" (optional, string) - The address the transaction is sent from. "to": "address" (optional, string) - The address the transaction is directed to. "gas": "quantity" (optional, string) - Integer of the gas provided for the transaction execution. eth_call consumes zero gas, but this parameter may be needed by some executions. "gasPrice": "quantity" (optional, string) - Integer of the gasPrice used for each paid gas "value": "quantity" (optional, string) - Integer of the value sent with this transaction "data": "data" (optional, string) - Hash of the method signature and encoded parameters. "nonce": "quantity" (optional, string) - Integer of a nonce. This allows to overwrite your own pending transactions that use the same nonce. }

Request

curl --location --request POST 'https://go.getblock.io/YOUR-ACCESS-TOKEN' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_sendTransaction", "params": [{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155", "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567", "gas": "0x76c0", "gasPrice": "0x9184e72a000", "value": "0x9184e72a", "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"}], "id": "getblock.io"}'

Response

{
    "error": {
        "code": -32000,
        "message": "unknown account"
    },
    "id": "getblock.io",
    "jsonrpc": "2.0"
}

Parameters

object - json object

The transacion call object in format: { "from": "address" (optional, string) - The address the transaction is sent from. "to": "address" (optional, string) - The address the transaction is directed to. "gas": "quantity" (optional, string) - Integer of the gas provided for the transaction execution. eth_call consumes zero gas, but this parameter may be needed by some executions. "gasPrice": "quantity" (optional, string) - Integer of the gasPrice used for each paid gas "value": "quantity" (optional, string) - Integer of the value sent with this transaction "data": "data" (optional, string) - Hash of the method signature and encoded parameters. "nonce": "quantity" (optional, string) - Integer of a nonce. This allows to overwrite your own pending transactions that use the same nonce. }

Request

curl --location --request POST 'https://go.getblock.io/YOUR-ACCESS-TOKEN' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_signTransaction", "params": [{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155", "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567", "gas": "0x76c0", "gasPrice": "0x9184e72a000", "value": "0x9184e72a", "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"}], "id": "getblock.io"}'

Response

{
    "error": {
        "code": -32000,
        "message": "nonce not specified"
    },
    "id": "getblock.io",
    "jsonrpc": "2.0"
}

GetBlock offers flexible plans and features to support developers and businesses at any stage, from small projects to high-traffic platforms. This section covers available plans, scaling features, and managing subscriptions and payments.

Parameters

limit -

Maximum number of events to retrieve. Gets default page size if not provided.

start -

Optional starting sequence number of events. Defaults to the most recent events.

Request

curl --location --request GET 'https://go.getblock.io/<ACCESS-TOKEN>/v1/accounts/0xc20ea5a196c81d8d7aff814aa37f8a5823acffbc4193efd3b2aafc9ef2803255/events/2?limit=10' \
--header 'Content-Type: application/json'

Response

[
    {
        "data": {
            "amount": "100000000000"
        },
        "guid": {
            "account_address": "0xc20ea5a196c81d8d7aff814aa37f8a5823acffbc4193efd3b2aafc9ef2803255",
            "creation_number": "2"
        },
        "sequence_number": "0",
        "type": "0x1::coin::DepositEvent",
        "version": "129456718"
    },
    {
        "data": {
            "amount": "0"
        },
        "guid": {
            "account_address": "0xc20ea5a196c81d8d7aff814aa37f8a5823acffbc4193efd3b2aafc9ef2803255",
            "creation_number": "2"
        },
        "sequence_number": "1",
        "type": "0x1::coin::DepositEvent",
        "version": "129525896"
    }
]

Parameters

DATA - string

address to check for balance.

QUANTITY - integer

Position in the storage.

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

curl --location --request POST 'https://go.getblock.io/<ACCESS-TOKEN>' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_getStorageAt", "params": ["0x9b956e3d318625be2686ae7268d81777c462d41f", "0x0", "latest"], "id": "getblock.io"}'

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x0000000000000000000000000000000000000000000000000000000000000000"
}

Parameters

DATA - string

Hash of a block.

QUANTITY - integer

Transaction index position.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": {
        "blockHash": "0xf5524f0cf99ac6bc5905e95294ebed9007e2d978155f3457118eb7a26d97503a",
        "blockNumber": "0x5206d53",
        "chainId": "0xa4b1",
        "from": "0x00000000000000000000000000000000000a4b05",
        "gas": "0x0",
        "gasPrice": "0x0",
        "hash": "0xaf256a9ce8839489dcaa4f9a2740bcd5865b3db34a15434cce29e6bdcf043bc7",
        "input": "0x6bf6a42d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000105e0460000000000000000000000000000000000000000000000000000000005206d530000000000000000000000000000000000000000000000000000000000000000",
        "nonce": "0x0",
        "r": "0x0",
        "s": "0x0",
        "to": "0x00000000000000000000000000000000000a4b05",
        "transactionIndex": "0x0",
        "type": "0x6a",
        "v": "0x0",
        "value": "0x0"
    }
}

Parameters

-

Request

curl --location --request GET 'https://go.getblock.io/<ACCESS-TOKEN>/v1/info' \
--header 'Content-Type: application/json'

Response

{
    "block_height": "58851650",
    "chain_id": 1,
    "epoch": "2796",
    "git_hash": "6568c5ee6a58b4f96c0780d4f66d7e573e61c418",
    "ledger_timestamp": "1685696086534090",
    "ledger_version": "152087593",
    "node_role": "full_node",
    "oldest_block_height": "1101178",
    "oldest_ledger_version": "2287593"
}

Parameters

-

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": {
        "arb": "1.0",
        "debug": "1.0",
        "eth": "1.0",
        "net": "1.0",
        "rpc": "1.0",
        "txpool": "1.0",
        "web3": "1.0"
    }
}

Parameters

DATA - string

address.

DATA - string

message to sign.

Request

curl --location --request POST 'https://go.getblock.io/YOUR-ACCESS-TOKEN' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_sign", "params": ["0x9b956e3d318625be2686ae7268d81777c462d41f", "0xdeadbeaf"], "id": "getblock.io"}'

Response

{
    "error": {
        "code": -32000,
        "message": "unknown account"
    },
    "id": "getblock.io",
    "jsonrpc": "2.0"
}

Parameters

DATA - string

Hash of a block.

QUANTITY - string

the uncle’s index position.

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": null
}

Parameters

DATA - string

address.

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x"
}

Parameters

address - data

the address of the new identiy.

Request

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

Response

{
    "result": "null",
    "id": "getblock.io",
    "status_code": 405,
    "message": "Method not allowed"
}

Parameters

-

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x6aacc1719383adeb356a720506fd2064"
}

Set up and manage blockchain node endpoints with GetBlock. This section covers creating shared node endpoints, generating access tokens, and configuring dedicated nodes with customizable settings.

Parameters

database - string

database name

key - string

key name

data - data

data to store.

Request

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

Response

{
    "result": "null",
    "id": "getblock.io",
    "status_code": 405,
    "message": "Method not allowed"
}

Parameters

object - json object

The transacion call object in format: { "from": "address" (optional, string) - The address the transaction is sent from. "to": "address" (optional, string) - The address the transaction is directed to. "gas": "quantity" (optional, string) - Integer of the gas provided for the transaction execution. eth_call consumes zero gas, but this parameter may be needed by some executions. "gasPrice": "quantity" (optional, string) - Integer of the gasPrice used for each paid gas "value": "quantity" (optional, string) - Integer of the value sent with this transaction "data": "data" (optional, string) - Hash of the method signature and encoded parameters. }

QUANTITY|TAG - string

integer block number, or the string "latest", "earliest" or "pending".

Request

curl --location --request POST 'https://go.getblock.io/<ACCESS-TOKEN>' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_call", "params": [{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155", "to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567", "gas": "0x76c0", "gasPrice": "0x9184e72a000", "value": "0x9184e72a", "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"}, "latest"], "id": "getblock.io"}'

Response

{
    "error": {
        "code": -32000,
        "message": "err: insufficient funds for gas * price + value: address 0xb60E8dD61C5d32be8058BB8eb970870F07233155 have 0 want 304000002441406250 (supplied gas 30400)"
    },
    "id": "getblock.io",
    "jsonrpc": "2.0"
}

Parameters

QUANTITY|TAG - integer or string

block number or "latest", "earliest" or "pending"

Request

curl --location --request POST 'https://go.getblock.io/YOUR-ACCESS-TOKEN' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc": "2.0", "method": "eth_getUncleCountByBlockNumber", "params": ["latest"], "id": "getblock.io"}'

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "0x0"
}

Parameters

-

Request

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": "42161"
}

Parameters

data - hex string

A subscription ID previously generated with eth_subscribe method.

Request

Response

{
    "jsonrpc":"2.0",
    "id":"getblock.io",
    "result":true
}

These tools help ensure optimal use of GetBlock’s services and keep you informed of key metrics and events related to your account.

Dashboard

The Dashboard provides a quick snapshot of key metrics:

• Your current plan details

• Remaining CU balance

• Rate limit based on your plan

• Total requests made in the last 24 hours

Detailed statistics

For more detailed analysis, visit the Statistics tab in ‘My Endpoints’ section.

Select the time period, protocol name, networks (mainnet/testnet), and API interfaces to analyze the data by parameters.

All data is displayed through infographics, including:

• Number of requests

• Response statuses

• Method call distribution

• Rate limit rejections

Notifications

GetBlock provides a notification system to help you monitor your usage and subscription status.

Alert types:

• Run out of CU: Notifies you when your CU balance reaches zero.

• CU balance alerts: Warns when remaining CUs drop below specified limits.

• Subscription expiration alerts: Help you renew your dedicated node plans on time.

Set up email, Telegram, or Webhook alerts to monitor your usage and subscription status from Settings → Notification Settings.

Fiat payments

Users can pay for subscriptions using traditional fiat currency via Paddle.

How it works:

• Recurring payments enabled by default: Payment is automatically deducted on the billing date.

• Fees: VAT is applied to Paddle payments and varies depending on your region

• If the card balance is insufficient: GetBlock will retry the payment after three days. If the retry fails, the plan will be frozen until the payment is resolved.

Updating your payment details

To update your payment information while you have an active subscription:

1. Go to Pricing → Manage Plans.

2. Click ‘Edit Payment Method’.

3. Enter your updated payment details and save the changes.

Crypto payments

Users can top up their accounts with cryptocurrency through NOWPayments.

How it works:

• Payments are processed as one-time transactions: add funds as needed.

• Supported cryptocurrencies: any token on any network available through NOWPayments at the time of payment.

• Fees: blockchain network fees apply.

Connection issues

JSON-RPC errors

How to make HTTP requests with curl using JSON config file

Using GetBlock’s JSON configuration file with curl is particularly helpful when you need to access various node endpoints without hardcoding API keys in the code:

1. Download the getblock.config.json file from your GetBlock account;

2. Make sure you have installed. jq is a versatile command-line tool that enables extracting values from JSON files;

3. Navigate to your workspace or directory where you have imported the getblock.config.json file and open a terminal;

4. Now, you can make a GET request to a selected node endpoint using the curl command:

How to use GetBlock’s JavaScript config with Web3.js

Connect to Ethereum nodes and other EVM-compatible networks using web3.js and GetBlock’s JS configuration file.

1. Make sure the web3.js library is added to your project. In order to do that, use one of the following methods:

• Npm: npm install web3

• Yarn: yarn add web3

• Pure js link: dist/web3.min.js

1. Download the getblock.config.js file from your GetBlock account. Add this file to your project directory.

2. Import the getblock module to a .js file that configures a new Web3 instance:

1. Connect to an Ethereum node and start sending API calls using web3.js over HTTP or WebSocket in the format below:

Use go() method to access an entire endpoint or token() to fetch the token.

How to use the JS config with Hardhat

Set up GetBlock’s JS config file in Hardhat following the steps below:

1. Ensure you have Hardhat installed as a dependency in your Node.js project or run the following command to do so:

1. Navigate to your GetBlock account and install the getblock.config.js file. Copy and paste it into your working directory;

2. Open the hardhat.config.js file from your project directory and import the getblock module:

1. To set up GetBlock as a provider, modify the Hardhat configuration file with the credentials as shown below. Use go() method to access an entire endpoint or token() to fetch the token only.

Parameters

DATA - string

Hash of a block.

Boolean - Boolean

If true it returns the full transaction objects, if false only the hashes of the transactions.

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

object - json object

The transacion call object in format: { "from": "address" (optional, string) - The address the transaction is sent from. "to": "address" (optional, string) - The address the transaction is directed to. "gas": "quantity" (optional, string) - Integer of the gas provided for the transaction execution. eth_call consumes zero gas, but this parameter may be needed by some executions. "gasPrice": "quantity" (optional, string) - Integer of the gasPrice used for each paid gas "value": "quantity" (optional, string) - Integer of the value sent with this transaction "data": "data" (optional, string) - Hash of the method signature and encoded parameters. }

QUANTITY|TAG - string

Optional.

integer block number, or the string "latest", "earliest" or "pending".

Request

Response

Solana applications often need live, high-throughput access to on-chain events. Solana gRPC plugin solves this core problem of real-time blockchain data access.

What is Yellowstone gRPC?

Yellowstone gRPC is the name given to the Dragon’s Mouth Geyser plugin’s gRPC interface in Triton One’s “Yellowstone” suite for Solana. It allows opening streams and subscribing to native Solana on-chain events, receiving every new update in real time, with millisecond-level latency.

By plugging directly into validators, it pushes new blocks, transactions, and account updates to your backend the moment they occur.

How Yellowstone gRPC Geyser works

The Geyser Plugin hooks into validator callbacks for ledger events and publishes those events to its own internal queues. A gRPC server then streams the queued events over the network to subscribed clients.

Supported data streams & subscriptions

Geyser gRPC supports streaming the full range of common Solana events:

• Account updates (writes): Every time an account’s data changes, a notification is emitted.

• Transactions: Each transaction processed by the leader generates a stream event with all associated account changes.

• Ledger entries: Low‑level entry/shred events (raw blocks of ledger data) can also be streamed.

• Block notifications: Clients can subscribe to be notified when a new block is completed.

• Slot notifications: New slot boundaries (leaders or votes) can trigger slot events.

Every update stream can include full transaction metadata, instruction details, and parsed logs – essentially everything you’d see in a getTransaction or getProgramAccounts call, but pushed in real time.

In addition to streaming methods, Dragon’s Mouth also exposes several unary RPCs via the same gRPC interface for quick queries about:

• The Slot;

• Block height;

• Latest blockhash;

• Valid blockhash.

Together, this provides a way to both fetch state on demand and receive updates in real time.

Yellowstone gRPC API features

• Near-zero latency: By streaming directly from leaders, Dragon’s Mouth delivers updates often hundreds of milliseconds faster than standard RPC/WebSocket APIs.

• High throughput: The plugin can handle millions of events per minute under load, built for Solana’s high transaction volume. Optional compression can be applied for even more efficiency.

• Built-in support for bi-directional streaming: Keep-alives, ping/pong frames help maintain long-lived connections.

• Comprehensive streaming: Clients can monitor virtually anything: token mints, program interactions, votes, etc.

• Protobuf/binary encoding: Each message arrives parsed and typed, not raw base64. Clients get structured fields (account diffs, token balance changes, parsed logs, etc.) instead of raw blobs.

• Rich filtering: You can apply filters (by account key, owner program, data patterns, commitment level, etc.) so only matching updates are streamed.

Overall, applications can keep pace with Solana’s peak TPS without data loss, receive only relevant updates, save bandwidth, and react faster.

Solana Geyser gRPC plugin use cases

Solana gRPC streaming capabilities are crucial for time-sensitive applications, apps that need to react the moment on-chain state changes without manual refreshes.

gRPC API ideal use cases include:

• High-frequency trading or arbitrage systems (e.g. MEV bots);

• On-chain indexers & archives;

• Live analytics;

• Real-time monitors for DEXes, NFTs, wallets, etc.;

• Alerting & notification systems;

• DeFi strategy engines;

• ..and any app that needs push‑style updates.

Why use Yellowstone gRPC API?

Using Yellowstone gRPC for your Solana data means you get a high-throughput, low-latency, bidirectional streaming channel.

Instead of polling REST endpoints every few seconds or using Solana’s WebSocket API (which typically only updates after a block finalizes), the gRPC interface allows tracking every new event down the wire as it happens.

Overall, it removes much of the boilerplate: your backend code subscribes once, then simply reacts to incoming messages

MetaMask is a blockchain wallet available as a mobile application and a browser extension. It allows you to interact with Ethereum-based decentralized applications (dApps) directly from your browser.

This step-by-step tutorial will guide you through connecting GetBlock’s powerful nodes to your MetaMask wallet.

Before you start

Set up your wallet

If you don’t already have MetaMask, download and install it from the official website: https://metamask.io/download.

MetaMask extension is officially supported on Chrome, Brave, Firefox, Microsoft Edge, and Opera browsers.

Get a custom RPC URL

Generate a JSON-RPC URL for the selected network from your GetBlock account and copy it.

Add GetBlock RPC to an existing network

If the network is already in your list but uses a default RPC provider, you can switch to GetBlock by following these steps:

1. Click on the current network name in MetaMask to open the dropdown of networks.

2. Find the network you want to edit and click the settings menunext to it. Select 'Edit'.

1. Open the ‘Default RPC URL’ dropdown and select 'Add RPC URL'.

2. Paste the JSON-RPC endpoint URL from your GetBlock account (https://go.getblock.io/<ACCESS_TOKEN>/).

3. Name the new RPC URL for easier identification.

1. Click 'Add URL', then 'Save' to confirm.

You can now switch between RPC URLs for that network as needed.

Add a new network to MetaMask

If the network isn’t in your list, you can add it as a custom network. For this example, we will add the Polygon zkEVM to MetaMask.

1. Click on the current network name.

2. Select 'Add a custom network'.

1. Fill in the required fields:

1. Click 'Save', and the custom network will be added and selected as default.

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

GetBlock offers three main service options—Shared Nodes, Dedicated Nodes, and Enterprise Solutions. This page provides a high-level overview of these services.

You can explore detailed pricing and plans from your dashboard in the “Pricing” section or via .

Shared nodes

Shared nodes operate on a resource-sharing model, where multiple clients access the same underlying node infrastructure maintained by GetBlock.

Our Shared Nodes deliver the perfect balance between affordability and performance:

• Cost efficiency: Benefit from our pricing model based on , so you only pay for the resources needed for your current workload.

• Flexible pricing: Options range from a free to high-volume plans — accessible for individual developers and smaller teams while supporting the scaling needs of growing dApps.

• Consistent performance: Each plan enforces a Requests Per Second (RPS) limit, preventing individual spikes from impacting overall quality.

• Tiered support levels: Support options adapt to your requirements, from basic help to priority support when you need it most.

• Multi-chain accessibility: Prototype, test, and deploy applications across different networks without the complexities of connecting to each blockchain individually.

Dedicated nodes

A Dedicated Node is a private RPC server deployed solely for your use case. That means consistent throughput, no API rate throttling due to other users, and better uptime guarantees.

This option is ideal for users that require high performance, full control over node configuration, and a flawless connection to the blockchain without any limitations:

• Mission-critical reliability: Maximized uptime and robust failover mechanisms for even more reliable service.

• Unlimited usage: No per-second request caps or CU tracking.

• Low latency: With servers available in Europe, Asia, and the USA, choose the optimal server location to minimize latency and enhance performance for your users

• Fully customizable: Complete control over your node configurations, including access to archive data.

• Predictable pricing:

  • Full Node: $1,000/month;

  • Archive Node: $1,500/ month.

• Expert support: 24/7 coverage and immediate issue resolution.

Enterprise solutions

This option is designed to meet the needs of organizations operating at scale or applications that require extra resources, features, and dedicated support.

What’s included:

• 99.9% uptime guarantee

• Customizable node configurations and integrations

• Performance optimization via load balancers

• Advanced analytics and alert systems

• Priority assistance from GetBlock experts

Visit the to learn more about how we tailor services to fit complex, high-demand environments.

Parameters

limit -

Maximum number of resources to retrieve. Gets default page size if not provided.

ledger_version -

Ledger version. Defaults to latest if not provided.

start -

Optional cursor specifying pagination start. You can call this endpoint once without this parameter, and then use the cursor returned in the X-Aptos-Cursor header in the response.

Request

Response

This guide explains how limits work across all available plans, helping you understand what’s included and how to choose the option that best fits your current workload and future growth.

Shared node limits

GetBlock’s shared node service is subject to several usage limits. These are the key limits that directly affect costs and performance:

• CU (Compute Units): Measures the computational effort required to process requests. Different shared node plans include a varying number of CUs that you can use in a month.

• RPS (Requests Per Second): Each plan enforces a maximum number of requests you can send every second. While you’re not billed per request, staying within this limit is critical to maintaining optimal service quality.

• Access Tokens: Access tokens are unique identifiers used to authenticate your connection to GetBlock’s node infrastructure, generated when you create an endpoint. The limitation on your plan determines how many of these access tokens (and therefore endpoints) you can create.

To see the full comparison table, navigate to https://getblock.io/pricing/.

Managing unused & extra CUs

If you don’t use all your allocated CUs within a month, the unused amount will carry over to the next month as long as your subscription is active and renewed. If your subscription expires or is not renewed on time, the remaining CUs will be lost.

Dedicated node limits

Our Dedicated Node service is perfect for teams and projects that demand absolute freedom from rate limits and CU monitoring.

• CU: Unlimited

• Rate: Unlimited

If you’re unsure which plan best fits your needs, our team is ready to help! Contact our support team or visit our Choosing your plan page for more information.

Brave Wallet supports many networks and offers extensive customization options. However, each of its chains uses a public RPC API endpoint, which is very bad for privacy and efficiency.

GetBlock’s private RPC nodes can solve this problem. After downloading the Brave browser and setting up the wallet, visit https://account.getblock.io/ and get one of the 60+ available chain endpoints.

Every wallet’s network can be modified this way, and this step-by-step guide shows how to do that.

Before you start

You need to set up the Brave wallet and prepare the GetBlock API endpoints.

Download Brave and set up the wallet

Brave Wallet is inseparable from the Brave browser. So, download and install the browser from the official website. It’s available for desktop, Android, and iOS.

After opening the browser, look at the wallet icon in the upper right corner. Click on it to open the Brave Wallet. Import the account using a seed phrase or create a new one.

Now, it’s time to prepare the working part: the GetBlock node.

Get a custom RPC API endpoint

1. Proceed to the GetBlock dashboard and create an account or log in.

2. Click on the Get button to add a new RPC endpoint, and select the Ethereum mainnet.

3. Pick the endpoint location. Currently, the Frankfurt and New York regions are available for a free node. Selecting the physically closest one is usually the best option.

4. Click Get, and the endpoint is ready.

It’s now available via the access token URL and can be used to perform transactions, deploy smart contracts, and much more.

Free node endpoints offer a generous 50,000 free compute units per day with a 5 RPS limit. It’s more than enough for single-person activities.

Modify an existing EVM network

Brave Wallet supports a wide range of EVM and non-EVM networks. Let’s modify an Ethereum account.

Go to the wallet, and try to perform some actions with the Ethereum account:

• Check the balance

• Connect to dApps

• Execute smart contracts

• Make a transaction

In the GetBlock dashboard, track the remaining compute unit balance.

Add a new EVM network

If a network of interest isn’t included in the network list, it can be added manually. Let’s add the Polygon zkEVM network, a zero-knowledge L2.

It’s recommended to assign a custom account name, such as “Polygon zkEVM GetBlock,” to distinguish the dedicated account.

Then, return to the wallet and locate a new Polygon zkEVM account with the ETH native token and a custom name.

As with GetBlock’s Ethereum node, track the compute units usage at the GetBlock dashboard.

This page explains how to manage your dedicated node subscriptions, including checking their status and extending the service duration—all from your user account.

Tracking subscription status

You can monitor the status of your dedicated node subscriptions in three different ways.

1. Dashboard

The widget on your dashboard alerts you when your subscription is about to expire or is in a grace period. Click the widget to open a pop-up that lists all nodes that require renewal.

2. Plan manager

The Manage Plans section can be found by navigating to the “Pricing” option in the left-side menu. You'll see three tabs: click on “Manage Plans” to view all your subscriptions in one place.

3. "My endpoints" list

Each endpoint in “My endpoints” list now shows its current subscription status.

Subscription statuses

Changing the subscription period

You can modify your subscription period at any time if you’re on a one-time payment plan paid with:

• Cryptocurrency;

• Credit card.

Available options

You can extend your subscription to one of the following periods:

• 1 month

• 6 months

• 12 months

How to extend your Dedicated Node plan

There are three ways to extend your subscription.

Option 1: The Dedicated Nodes dashboard

1. Go to Dedicated Nodes tab from your dashboard. Look for the subscription alert widget.

1. Click the widget to see a list of nodes needing renewal and choose one. A pop-up will show extension options (1, 6, or 12 months).

1. Choose a new period and review details. Proceed to checkout.

2. Complete the payment by following the instructions provided.

3. Check the "Payment History" under the Pricing tab to track the progress.

Video guide

Option 2: From “My Endpoints” list

1. Navigate to your main dashboard and switch to the Dedicated Nodes tab.

2. Choose a node to extend. Expand the node’s details and click "Extend" to begin the process.

3. Follow the pop-up instructions to select the new subscription period and finalize the process.

Option 3: Via the "Manage Plans" menu

1. Navigate to Pricing > Manage Plans.

2. Review all subscriptions. Subscriptions nearing expiration are listed at the top.

3. Follow the same steps: Select your node, choose a new period, and confirm your payment.

How to keep your Dedicated Node running smoothly

• Keep an eye on your subscription. Check your dashboard or plan manager to track expiration dates. Status tracking is now easier with our latest updates.

• Avoid disruptions by renewing before your subscription ends. This ensures your node remains active and accessible without downtime.

• For recurring payments, ensure your card information is up to date. Payment failures (e.g., expired card) can interrupt service.

If you face any issues with renewal or extensions, feel free to reach out to GetBlock support—we’re happy to assist.

Getting Started with GetBlock

To get started, follow these steps:

1. Sign up: Create an account to access your Access Token.

2. Generate access token: Navigate to the dashboard, and generate your first access token for API authentication.

3. Choose the blockchain name and type: Select the blockchain network you want to interact with, set up testnet/mainnet, and choose the interface you’re going to use.

4. Send your first request:

import requests
url = "https://go.getblock.io/<ACCESS-TOKEN>/"
headers = { "Content-Type": "application/json" }
payload = { "jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": "getblock.io" }
response = requests.post(url, headers=headers, json=payload)
print(response.json())

Key Features of GetBlock

GetBlock is offering one of the most comprehensive APIs toolkits in the segment supporting hundreds of dApps with fast and reliable connection to blockchain nodes.

50+ blockchains in store

• Seamless connection to full and archive nodes

• Shared and dedicated nodes: Tailored for your dApp’s needs.

• Programmable and non-programmable blockchains

• L1 and L2 protocols

• EVM and non-EVM networks

See full list: https://getblock.io/nodes/ All mainstream RPC interfaces

• WebSockets

• JSON RPC

• GraphQL

• REST API

• And more to come

Add them in Lego-like manner: https://account.getblock.io/

Industry-leading suite of add-ons and ready-made APIs

• DAS API

• Firehose

• Blockbook

• Yellowstone Geyser

Need more? Don’t hesitate to contact sales: https://getblock.io/contact/

Examples for Console REST API Requests

cURL

Most *nix-based systems come with cURL pre-installed. cURL is a command-line tool and library for transferring data with URLs. To check if cURL is installed, run the following command:

curl -h

Example of requesting the latest block number using the GetBlock API and cURL:

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"
}'

Python

To run Python examples, ensure Python is installed along with the requests package. You can install the package using the following command:

python -m pip install requests

Example:

import requests
url = "https://go.getblock.io/<ACCESS-TOKEN>/"
headers = { "Content-Type": "application/json" }
payload = { "jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": "getblock.io" }
response = requests.post(url, headers=headers, json=payload)
print(response.json())

JavaScript

For JavaScript examples, you'll need Node.js version 18 or later. Follow the official documentation to install the latest stable version globally. Verify your installation by running:

node -v

Ruby

To execute Ruby examples, install Ruby on your machine. Refer to the official installation guide for details. Confirm installation by running:

ruby -v

Supported networks

We provide APIs for a wide range of networks, including:

Aptos (APT)

Arbitrum (ARB)

Avalanche (AVAX)

Bitcoin Cash (BCH)

BNB Smart Chain (BSC)

Bitcoin-SV (BSV)

Bitcoin (BTC)

Bitcoin Gold (BTG)

Cronos (CRO)

Dash (DASH)

DigiByte (DGB)

Dogeсoin (DOGE)

Polkadot (DOT)

Ethereum Classic (ETC)

Ethereum (ETH)

Fantom (FTM)

Fuse.io (FUSE)

Moonbeam (GLMR)

Gnosis Chain (GNO)

Huobi ECO Chain (HECO)

KuCoin Community Chain (KCC)

Kusama (KSM)

Polygon (MATIC)

Moonriver (MOVR)

Near Protocol (NEAR)

Harmony (ONE)

Ontology (ONT)

Optimism (OP)

Rootstock (RSK)

Solana (SOL)

Theta (THETA)

TON (TON)

Tron (TRX)

NEM (XEM)

Monero (XMR)

ZCash (ZEC)

In our Shared Node plans, we use CU-based pricing. CUs, Compute Units, is a way to measure the computational resources that each API request consumes.

Instead of charging a fixed fee for every call, GetBlock calculates the “cost” of processing a request based on the actual computational work involved – such as CPU & memory usage, and disk I/O.

Here's how it works:

• Different shared node plans include different allocations of Compute Units (CUs).

• Each API call deducts an amount based on the resources it consumes.

• Users can track their remaining CUs in real time on the dashboard.