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.

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.

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.

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.

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

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

-

Request

Response

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:

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

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

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

Get the chain ID

Identify the blockchain network with the eth_chainId method:

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

Response example:

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

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:

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

Example response:

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

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

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

-

Request

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

Response

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

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

-

Request

curl --location --request POST 'https://go.getblock.io/<ACCESS-TOKEN>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "jsonrpc": "2.0",
  "method": "net_listening",
  "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

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

database - string

Database name

key - string

key name

Request

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

Response

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

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

QUANTITY|TAG - integer or string

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

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_getUncleByBlockNumberAndIndex", "params": ["latest", "0x0"], "id": "getblock.io"}'

Response

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

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

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

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

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

Response

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

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

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_getBlockTransactionCountByNumber", "params": ["latest"], "id": "getblock.io"}'

Response

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

Connection issues

JSON-RPC errors

Import the collection into your Postman workspace: https://documenter.getpostman.com/view/28751185/2s9YRDzqcX.

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.

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.

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

DATA - string

address to check for balance.

QUANTITY|TAG - integer or string

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

Request

Response

Parameters

database - string

database name

key - string

key name

data - data

data to store.

Request

Response

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 the ‘Endpoints’ section.

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

All data is displayed through infographics, including:

• Number of requests and CUs

• 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.

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

Parameters

DATA - string

Hash of a transaction.

Request

Response

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

DATA - string

address.

QUANTITY|TAG - integer or string

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

Request

Response

Parameters

QUANTITY|TAG - integer or string

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

QUANTITY - integer

Transaction index position.

Request

Response

To create a 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. Customize your dedicated node with the following options:

   1. Region of deployment: Germany (Frankfurt), USA (New York), Singapore.

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

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

   4. Node client: Specify your preferred node implementation.

   5. Performance : Choose between High (premium specs, max throughput) and Standard (enterprise specs, optimized pricing for moderate-high loads).

   6. API interface: Select API options and add-ons if applicable.

3. 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. Once deployed, add as many access tokens for each dedicated node as you need.

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

Response

Parameters

DATA - string

Hash of a block.

QUANTITY - integer

Transaction index position.

Request

Response

Parameters

-

Request

Response

Parameters

-

Request

Response

Parameters

address - data

The identity address to add to a group

Request

Response

Parameters

-

Request

Response

Parameters

database - string

database name

key - string

key name

Request

Response

Parameters

DATA - string

The signed transaction data.

Request

Response

Parameters

DATA - string

hash of the block.

Request

Response

Parameters

-

Request

Response

Parameters

DATA - string

address.

QUANTITY|TAG - integer or string

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

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

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

Response

{
    "id": "getblock.io",
    "jsonrpc": "2.0",
    "result": {
        "baseFeePerGas": "0x5f5e100",
        "difficulty": "0x1",
        "extraData": "0xd79c44e4c3397b74b78db0ea2d34c1106d8bae0752d6e352a859ae27185dec62",
        "gasLimit": "0x4000000000000",
        "gasUsed": "0x9b0c67",
        "hash": "0x9a682d3983aa3c86a32cc87ca21ae5f5eb7b5d175155ed941238e60b681ad280",
        "l1BlockNumber": "0x10924a4",
        "logsBloom": "0x0808000400200000c0040000000000840000000100040200400000000000000c010002000000000006204000012000080000008000100000000040000000000000102021000000008000006800000000000000000002010010004001048004000000000003000000000100200000080000000000800080000000201004000000000000000000800000000000000008088002000400002000000000400800000002000001008000000008000000000080000020020000004000020000001000000000800200000800060820000081000209000c000084020400010100008020010000001400400002000000080000400040001024016004000000000000000000",
        "miner": "0xa4b000000000000000000073657175656e636572",
        "mixHash": "0x000000000001310800000000010924a4000000000000000a0000000000000000",
        "nonce": "0x00000000000d7b9a",
        "number": "0x5bc4077",
        "parentHash": "0x6becdeda3dd59cbd1d5a459407ba3ffc298a1c64c7af27756f43d0db21144a92",
        "receiptsRoot": "0x18dd23ed85557f5ddf1075d35012611580401daf7ecb8a906915ef2036e9425c",
        "sendCount": "0x13108",
        "sendRoot": "0xd79c44e4c3397b74b78db0ea2d34c1106d8bae0752d6e352a859ae27185dec62",
        "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
        "size": "0x2d3a",
        "stateRoot": "0xb7845bcebb2a06b61b66e468c4f28ffa73e281101113b32bb49f1fb445d6eb8f",
        "timestamp": "0x6476c9df",
        "totalDifficulty": "0x469632f",
        "transactions": [
            "0x44613c8636c24b26ef754c899cb5f48600ccfe13a0ee697b40a9e92a0cb25a72",
            "0x0543ea3f502977d188eff073db26a325c0dec7f72f7a5033e65b6728964e2231"
        ],
        "transactionsRoot": "0x7989d9339de2ea4c5434ab01c0d5aff3853d6a0d746f306562ebe7ecb49e2c74",
        "uncles": []
    }
}

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

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

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

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

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:

npm install tronweb

• Yarn:

yarn add tronweb

In your javascript file, define TronWeb:

const TronWeb = require('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:

const tronWeb = new TronWeb({
fullHost: "https://go.getblock.io/<ACCESS-TOKEN>/"
})

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):

const fullNode = new TronWeb.providers.HttpProvider("https://go.getblock.io/<ACCESS-TOKEN>/")
const solidityNode = new TronWeb.providers.HttpProvider("https://go.getblock.io/<ACCESS-TOKEN>/")
const eventServer = new TronWeb.providers.HttpProvider("https://go.getblock.io/<ACCESS-TOKEN>/")
const tronWeb = new TronWeb(fullNode, solidityNode, eventServer)

After this you can call any TronWeb method:

tronWeb.trx.getBlock('latest').then(result => {console.log(result)});

All API references can be found in the project documentation at https://developers.tron.network/reference

Method response:

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: .

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 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.

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.

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

• Regional endpoints: Connect to the nearest datacenter — Frankfurt (EU), New York (US), Singapore (APAC) — to minimize network latency.

• Archive data access: Run full historical blockchain queries.

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

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: from $1,000/month;

  • Archive Node: from $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.

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.

Parameters

data - hex string

A subscription ID previously generated with eth_subscribe method.

Request

Response

This endpoint gets the estimated gas price for executing a transaction in the Aptos blockchain network.

Supported Network

• Mainnet

Parameter

None

Request

Base URL

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

Example(cURL)*

curl --location 'https://go.getblock.io/<ACCESS_TOKEN>/v1/estimate_gas_price'

Response Example

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

Response parameter definition

Use Cases

This method can be used for:

• Wallets can auto-suggest gas fees based on the user's urgency.

• dApps can provide a “fast/normal/slow” fee slider to users.

• Developers can programmatically ensure transactions won’t fail due to low gas.

• Cost optimisation for batch transactions.

Code example

Node(axios)

const axios = require('axios');

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: 'https://go.getblock.io/<ACCESS_TOKEN>/v1/estimate_gas_price',
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

Python(Request)

import requests

url = "https://go.getblock.io/<ACCESS_TOKEN>/v1/estimate_gas_price"
response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

Error handling

Integration with Web3

By integrating /v1/estimate_gas_price into dApp, developers can:

• Provide real-time fee estimation inside wallets and dApps.

• Improve transaction confirmation rates by suggesting optimal gas.

• Enhance user experience with clear trade-offs (fast vs cheap).

• Avoid failed transactions due to underpriced gas.

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

This endpoint retrieves the latest information from the Aptos blockchain ledger, such as current chain ID, node role, latest and oldest ledger versions, epoch, block height, and more. In short, it provides an overview of Aptos and its health status.

Supported Network

• Mainnet

Parameters

• None

Request

URL (endpoint)

https://go.getblock.io/

Example (cURL)

curl --location 'https://go.getblock.io/<ACCESS_TOKEN>/v1/info'

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

Response Definition

Use Case

The /v1/info endpoint is useful for checking if a node is online and responding. For example:

• Developers can verify the latest block or ledger version to ensure the node is up-to-date.

• Applications can notify users about the health of the blockchain, such as showing a modal alerting them to the current state when they log in to a dApp.

Code Example (Axios)

import axios from 'axios'

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: 'https://go.getblock.io/<ACCESS_TOKEN>/v1/info',
  headers: {}
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

Replace <ACCESS_TOKEN> with your actual access token from GetBlock.

Error Handling

When using this endpoint, you may encounter:

• 404 → Incorrect or incomplete access token.

• 500 → Network issues.

How to fix:

• Use a stable and strong network connection.

• Check or re-copy your access token.

• Verify the URL to ensure it is correct and complete.

Integration

It is recommended to use this endpoint first to check the current status of the blockchain before integrating other endpoints into your application.

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

-

Request

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

Response

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

This short guide shows you how to create an RPC endpoint (an RPC URL) for any supported protocol in your GetBlock Shared Node dashboard to connect it to your app, script, or wallet.

The steps below cover how to generate a new endpoint URL with an Access Token:

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.

EU (Frankfurt):   https://go.getblock.io/<ACCESS_TOKEN>/
US (New York):    https://go.getblock.us/<ACCESS_TOKEN>/
Asia (Singapore): https://go.getblock.asia/<ACCESS_TOKEN>/

Full vs Archive mode

When creating an endpoint in your GetBlock Dashboard, for select protocols, you can choose between two node access modes – Full and Archive. This selection determines how much historical blockchain data your endpoint can access.

• Full mode: Standard full (pruned) node behavior — current state lookups, sending transactions, reading blocks, etc.

• Archive mode: Enables access to the historical chain state. Useful for querying balances, contract storage, UTXO sets, executing historical calls, simulating transactions at a past block, or reconstructing chain state for analytics and audits.

Viewing and managing endpoints

The created URL is shown on the endpoints list so you can copy it and start calling the node. Use the right-side menu () to roll (regenerate) or delete the endpoint from the list.

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:

• : 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 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 .

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! or visit our page for more information.

Overview

Yellowstone gRPC is a high-performance Solana Geyser plugin that provides real-time streaming access to on-chain data. Built by Triton One, it delivers blocks, transactions, and account updates with millisecond-level latency directly from Solana validators.

GetBlock offers managed Yellowstone gRPC endpoints as an add-on to Dedicated Solana Node subscriptions, eliminating the need for infrastructure setup and maintenance.

Key Features

• Near-zero latency: Streams data directly from validators, often hundreds of milliseconds faster than standard RPC/WebSocket APIs

• High throughput: Handles millions of events per minute under load

• Comprehensive streaming: Monitor accounts, transactions, blocks, slots, and program interactions in real-time

• Rich filtering: Subscribe only to relevant updates using account keys, owner programs, or commitment levels

• Protobuf encoding: Receive parsed, typed messages instead of raw base64 data

• Bidirectional streaming: Maintain long-lived connections with built-in keep-alives

Supported Data Streams

Yellowstone gRPC supports streaming the full range of Solana events:

Use Cases

Yellowstone gRPC is ideal for time-sensitive applications that need to react instantly to on-chain state changes:

• High-frequency trading and MEV bots

• On-chain indexers and data archives

• Real-time analytics dashboards

• DEX monitors and price feeds

• DeFi strategy engines

• Alerting and notification systems

• NFT marketplace trackers

• Wallet activity monitors

Getting Started

Prerequisites

To use Yellowstone gRPC on GetBlock:

• A GetBlock account (sign up at )

• A subscription

• Yellowstone gRPC add-on enabled (included at no extra cost with Dedicated Nodes)

Quick Example

Here's a minimal TypeScript example to start streaming account updates:

Additional Resources

Need Help?

Our support team is available 24/7 to assist with:

• Add-on activation and endpoint setup

• Integration guidance and troubleshooting

• Performance optimization

• Custom solutions for enterprise needs

Contact us through the or visit our .

GetBlock provides direct access to blockchain historical states through both the Dedicated Nodes service and archive-enabled Shared RPC endpoints.

This page covers Archive Mode – a setting that turns on archive-node access within GetBlock’s Shared Nodes subscription.

Common RPC use cases enabled by Archive Mode:

• Read contract/account state at any past block, not just latest , using methods like (address, blockNumber), (contract, slot, blockNumber), (address, blockNumber), etc.

• Call view functions against historical state: e.g. (..., blockNumber).

• Run historical queries and debugging that rely on old state: forensics, audits, explorers, indexing, and retroactive analytics.

• Support tracing and higher-fidelity debugging that may require historical state.

This feature removes the need to run a dedicated archive infrastructure for some use cases, letting developers perform on-demand historical queries via GetBlock RPC API.

Archive mode availability & coverage

Archive functionality is included with all Shared Node subscriptions, excluding the Free plan. No additional fee required.

Archive support is provided for a set of popular protocol mainnets, including Ethereum, BSC, Polygon, Base, Arbitrum, TRON, Sui, Cardano, etc.

Look for the small history icon ( ) when picking a protocol during the . It indicates that Archive mode is available for that blockchain.

How to enable the Archive mode

1. Sign in to your GetBlock dashboard and make sure you’re on the Shared Node tab.

2. Click Get endpoint and choose a required blockchain protocol.

1. Find the Mode toggle and switch the Archive mode on.

1. Finish configuring endpoint details by choosing the API interface and server location as usual.

After clicking Get, the new Archive endpoint appears in your Endpoints list. The endpoint URLs will follow the existing GetBlock format but point to archive nodes.

CU billing for Shared Archive endpoints

Archive endpoints usage remains subject to your plan’s .

However, serving requests from archive infrastructure involves heavier storage and compute power compared to regular full nodes.

Therefore, enabling the Archive mode affects how CU usage is calculated:

• GetBlock applies a 2× Compute Unit (CU) multiplier to all requests made through the Archive endpoint.

• The multiplier is applied to all requests made to an archive endpoint, even if the invoked RPC call does not require a historical state.

You can review the per-chain CU values for each method on our page.

Example:

If eth_getBalance costs 20 CU on a standard shared endpoint for a given chain, the same call to an Archive-enabled shared endpoint will cost 40 CU.

Plan accordingly and consider using standard Full mode endpoints for non-archive traffic to avoid unnecessary CU consumption.

Best practices

• Use archive endpoints only for workloads that require a historical state. For transactions or current state queries, use a standard Full mode to save CU.

• Monitor CU consumption on the dashboard and set alerts for spikes or when usage nears your plan limit.

• If you run sustained, high-volume archive queries, consider using a Dedicated Node.

💬 Need help with archive blockchain data?

what you’re building — our team can guide you to the most efficient archive node setup.

This endpoint retrieves account details, such as the number of transactions submitted by an account and its authentication key.

Supported Networks

• Mainnet

Parameters

Request Example

URL

Example

Response

Response Definition

Use Cases

This method can be used for:

• Wallets to fetch sequence numbers before sending transactions (to prevent replay attacks).

• Creating an account overview page or profile in a dApp.

• Validating if an account exists on-chain to avoid sending assets to the wrong account.

Code Examples

Python (requests)

Node.js (Axios)

Replace <ACCESS_TOKEN> with your actual access token from GetBlock.

Error Handling

You may encounter responses like:

This means the account hash is incorrect or the account does not exist on-chain at the current ledger state.

• 403 → Access token is missing.

Integration with Web3

By integrating /v1/accounts/{account_hash}, developers can:

• Fetch sequence numbers for transaction signing.

• Validate account existence and state (useful for onboarding users).

• Support wallet and dApp account management.

• Enable reliable transaction pipelines.

A team account is a shared workspace where multiple users can collaborate. This setup is ideal for companies and teams using GetBlock services.

Key benefits:

• Organized collaboration: Work together on company resources.

• Enhanced security: Role-based access limits each member to only the features they need.

• Efficient management: Easily switch between personal and team accounts.

A team account user is a regular GetBlock user. When invited to a team, they can work on company resources, manage service plans or team settings—provided the corresponding permissions are granted.

Creating a team account on GetBlock

This part covers a step-by-step guide to setting up your team workspace.

1. Sign in to your GetBlock account. If you don’t have a user account yet, create one following .

2. Click on the profile icon in the bottom-left corner of the sidebar. Select "Create new team" from the dropdown menu.

1. A popup window will appear. Assign a team name and click the "Create team" button.

1. Once the space is created, navigate to Account Settings > Team to manage team settings or add teammates.

Adding teammates

The creator of the team account controls who gets invited and manages user roles.

You can invite team members to join your team account using either their email address or GetBlock User ID.

• If the teammate has a GetBlock account: You can invite them using their ID. Since they are already registered, they just need to accept the invitation.

• If the teammate is not registered on GetBlock: Invite them via email so they can first create an account before joining the team.

A team member is marked as when they have successfully accepted the invitation and joined the team.

If the invitation has been sent but not yet accepted, their status remains .

Managing roles & permissions

Once the user has joined, the team owner or an admin can update their permissions:

1. Go to My Team in Account Settings.

2. Click the three-dot menu (⋮) next to a team member.

3. Select "Edit access level".

4. Assign permissions:

   • Endpoints: Create and manage node endpoints, access tokens, and view statistics.

   • Subscriptions & payments: Handle payments and plans.

   • Admin: Includes all the above permissions, plus the access to manage team settings and member roles.

5. Save changes.

Roles-based permissions

This table provides a breakdown of actions team account users can perform based on their role.

Revoking team access

To remove a user from your team account:

1. Navigate to Team in the Account Settings.

2. Click the three-dot menu (⋮) next to the team member name.

3. Select "Remove" from the dropdown menu.

How to join a team account

If you’ve been invited to a team on GetBlock, follow these steps to accept the invitation and join the team.

Switching between personal & team accounts

To switch between your personal account and any team accounts you are part of:

• Click the account icon in the left panel.

• A dropdown will show all teams & personal accounts.

• Switch between them as needed.

The teams list is sorted by recent activity, with the most recently accessed accounts at the top.

Best practices for team security

• Regularly review and audit permissions. Revoke access for users who are no longer active.

• Grant admin privileges only to trusted team members.

• Give Members only the necessary permissions (e.g., endpoints access or subscriptions management).

• Never share login credentials—use team accounts instead.

Need help?

If you run into any issues or have questions, please check out our or visit our . You can also use the Help button within your GetBlock dashboard to access support or submit a request.

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 .