1 of 100

GitHub sync

Welcome

Welcome to GetBlock! We make it easy for developers and businesses to connect to 100+ blockchain networks.

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 100+ 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

GETTING STARTED

How to set up an account

To start using GetBlock's services, you need to register an account. You’ll be ready to go in just a few clicks!

Go to GetBlock

Visit the homepage and click on the 'Dashboard' button in the upper-right corner, or use this direct link.

Choose the sign-up method

Register with Email
Enter your name and email address, then verify your email to activate the account.
Sign in via Google
Google will share your name, email, language preferences, and profile picture with GetBlock.

Review and accept policies

During registration, you will be asked to accept our and .

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 GetBlock user ID located in the ‘Settings’ section or simply click your account icon to view and copy it. Please use it when contacting GetBlock’s team so we can identify your account and help you faster.

Access token management

GetBlock uses a secure authentication method based on access tokens to ensure that only authorized users can interact with blockchain nodes.

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.

Plans and limits

GetBlock offers scalable plans tailored to developers and businesses, providing flexible solutions for both small projects and high-traffic platforms.

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.

Choosing your plan

Compare GetBlock's subscription options to find the one that fits your project.

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

Top up CUs and boost limits

GetBlock users can top up their CU balance or upgrade to higher limits directly from their Dashboard, with a few click.

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

Payment methods

GetBlock supports both fiat and crypto payments.

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.

Please, account for VAT when planning your payments.

Updating your payment details

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

Go to Pricing → Manage Plans.
Click ‘Edit Payment Method’.
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.

If the network fees are insufficient or the transaction fails, the payment will not be processed and the subscription plan will not be activated. Please, include enough gas fees to ensure the transaction processes successfully.

Endpoint setup

Configure and manage blockchain node endpoints through GetBlock, offering easy creation of shared nodes

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.

Testing RPC connection

This section provides simple examples to help you test your connection to the blockchain, using Ethereum API as a reference.

Using cURL for testing

These examples provide a starting point for testing your connection and querying blockchain data using cURL commands.

Before you start:

Create a JSON-RPC endpoint for the Ethereum blockchain from your GetBlock account.
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).

For a list of supported RPC methods with examples, navigate to .

Postman Collection

Download the Postman GetBlock’s collection to test our service. It includes all the accessible endpoints of our nodes and ready-to-go examples.

Import the collection into your Postman workspace: .

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.
Select the desired network from the drop-down list on the sidebar.

Errors and troubleshooting

This page provides a guide to common JSON-RPC and HTTP errors when testing your connection with GetBlock's API.

Connection issues

Code

Error message

Solution

JSON-RPC errors

Code

Error message

Solution

Monitoring and analytics

Track and manage your usage and node service subscriptions with GetBlock.

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:

BSC Advanced Tooling

Sending Transactions to Private Mempool (Priority Fee)

Learn how to add tips to transaction while sending to private mempool

Priority fees incentivize builders to include your transaction faster and position it more favorably within a block. Adding a tip to your private transaction provides three key benefits:

Higher inclusion probability: Builders prioritize transactions with higher fees
Better block positioning: Achieve positions 1–2 more reliably
Faster confirmation: Reduce waiting time for transaction inclusion

Choosing a Method

They are Two approaches exist for adding priority fees to private transactions:

Method

Best For

Trade-offs

Different Between Bundles and Transactions

Choose the appropriate method based on your use case:

Next Steps

Learn how to submit transactions via or method to the private mempool.

Solana Advanced Data Tools

ADD-ONS

GUIDES

Using Web3 libraries

Learn how to interact with blockchain networks through GetBlock’s node infrastructure using popular web3 libraries.

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.

Web3.js integration

Learn how to use Web3.js, a widely-used JavaScript library for connecting to GetBlock nodes.

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 install web3

yarn add web3

Set up your connection to GetBlock

For additional methods and options, refer to the official .

How to generate accounts and send transactions

This guide explains how GetBlock users can connect to blockchain nodes to create accounts and send transactions.

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

Ethers.js integration

Set up GetBlock as a provider using Ethers.js library to interact with the blockchain and streamline your dApp development process.

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:

yarn

Set GetBlock as a provider

For further details and advanced usage, explore the .

TronWeb integration

In this guide, we will show you how to get started with TronWeb to connect to GetBlock.

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:

API REFERENCE

db_getHex {disallowed} - Arbitrum

Example code for the db_getHex JSON RPC method. Сomplete guide on how to use db_getHex JSON RPC in GetBlock Web3 documentation.

Parameters

database - string

Database name

key - string

db_getString {disallowed} - Arbitrum

Example code for the db_getString JSON RPC method. Сomplete guide on how to use db_getString JSON RPC in GetBlock Web3 documentation.

Parameters

database - string

database name

key - string

db_putHex {disallowed} - Arbitrum

Example code for the db_putHex JSON RPC method. Сomplete guide on how to use db_putHex JSON RPC in GetBlock Web3 documentation.

Parameters

database - string

database name

key - string

db_putString {disallowed} - Arbitrum

Example code for the db_putString JSON RPC method. Сomplete guide on how to use db_putString JSON RPC in GetBlock Web3 documentation.

Parameters

database - string

database name

key - string

eth_coinbase {disallowed} - Arbitrum

Example code for the eth_coinbase JSON RPC method. Сomplete guide on how to use eth_coinbase JSON RPC in GetBlock.io Web3 documentation.

Parameters

Enabling archive mode

Enable Archive Mode on your GetBlock Shared Node API to access the full blockchain history and run historical queries

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

If you need an archive data for a chain not covered by shared Archive mode, request a . Dedicated Nodes can be deployed in archive mode for any supported blockchain and come with additional benefits like:

Full blockchain history at the highest throughput

How to enable the Archive mode

Sign in to your GetBlock dashboard and make sure you’re on the Shared Node tab.
Click Get endpoint and choose a required blockchain protocol.

Find the Mode toggle and switch the Archive mode on.

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.

Connect Brave Wallet to GetBlock

Explore how to add custom GetBlock RPC endpoints to Brave Wallet for greater security, transaction speed, and reliability

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 100+ available chain endpoints.

Using custom GetBlock nodes improves the Web3 experience in many ways:

Secure connections without privacy breaches
Lower latency and higher transaction speed
No overloads even during high chain activities

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

Proceed to the GetBlock dashboard and create an account or log in.
Click on the Get button to add a new RPC endpoint, and select the Ethereum mainnet.
Pick the endpoint location. Currently, Frankfurt, Singapore, and New York endpoints are available for a free node. Selecting the physically closest one is usually the best option.

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

Without a subscription, you may have only 2 endpoints simultaneously. If you need more, consider deleting those you don’t need at the given moment.

Free node endpoints offer a generous 50,000 free Compute Units per day with a 20 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 Brave Wallet settings

In the upper right corner of the wallet interface, click on the three-dot options () button and select Settings. Here, a list of supported networks can be found.

Locate the network in the list

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

Brave Wallet is very convenient for managing blockchain networks, with hundreds of EVM protocols available. GetBlock almost certainly has a node endpoint for active and popular ones.

If you genuinely believe that a network is unfairly missing, you may and suggest it.

Search the network ID in Brave settings

Return to the Wallet Networks menu. Instead of selecting existing networks, click on the Add button. Start typing “polygon zkevm” to locate the network quickly.

After clicking on it, Brave fills all required fields automatically.

Get a network’s RPC URL at GetBlock

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.

{
    "version": "3556737308",
    "hash": "0x4c3248d4c2f3a5ca1617e43e69332c66586478871ee44634cdb4554fe537dff6",
    "state_change_hash": "0x50148eff819eeb093efbe1cb56936ba02b3169db3343f5df0cb47aba016ea227",
    "event_root_hash": "0x1c432ce28a587287ef8abf14f025b78f5e288e886f16f217919cd2e35274f5f3",
    "state_checkpoint_hash": null,
    "gas_used": "195",
    "success": false,
    "vm_status": "Move abort in 0x31deb490728ae8e1a89675ee4c1877af8e5849c526d2c9a64238c49d8ece08a0::fa: E_NO_PROFIT(0x385): ",
    "accumulator_root_hash": "0xdc354eb8f4a96e9267bab2727240965becd154e35a21fede212af96f56333955",
    "changes": [
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::coin::PairedCoinType",
                "data": {
                    "type": {
                        "account_address": "0x1",
                        "module_name": "0x6170746f735f636f696e",
                        "struct_name": "0x4170746f73436f696e"
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::coin::PairedFungibleAssetRefs",
                "data": {
                    "burn_ref_opt": {
                        "vec": [
                            {
                                "metadata": {
                                    "inner": "0xa"
                                }
                            }
                        ]
                    },
                    "mint_ref_opt": {
                        "vec": [
                            {
                                "metadata": {
                                    "inner": "0xa"
                                }
                            }
                        ]
                    },
                    "transfer_ref_opt": {
                        "vec": [
                            {
                                "metadata": {
                                    "inner": "0xa"
                                }
                            }
                        ]
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::fungible_asset::ConcurrentSupply",
                "data": {
                    "current": {
                        "max_value": "340282366920938463463374607431768211455",
                        "value": "25726501655234340"
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::fungible_asset::Metadata",
                "data": {
                    "decimals": 8,
                    "icon_uri": "",
                    "name": "Aptos Coin",
                    "project_uri": "",
                    "symbol": "APT"
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::object::ObjectCore",
                "data": {
                    "allow_ungated_transfer": true,
                    "guid_creation_num": "1125899906842625",
                    "owner": "0x1",
                    "transfer_events": {
                        "counter": "0",
                        "guid": {
                            "id": {
                                "addr": "0xa",
                                "creation_num": "1125899906842624"
                            }
                        }
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0xa",
            "state_key_hash": "0x1db5441d8fa4229c5844f73fd66da4ad8176cb8793d8b3a7f6ca858722030043",
            "data": {
                "type": "0x1::primary_fungible_store::DeriveRefPod",
                "data": {
                    "metadata_derive_ref": {
                        "self": "0xa"
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0x60d8ef2e962b1d1b4f602c72e23eed6fbba86eefb41853a7688073fc918d912",
            "state_key_hash": "0x222b15ff81f90d75937ef6012807f0de0e0d488ccb5a229e55a954bc7870c75d",
            "data": {
                "type": "0x1::fungible_asset::FungibleStore",
                "data": {
                    "balance": "566263899",
                    "frozen": false,
                    "metadata": {
                        "inner": "0xa"
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0x60d8ef2e962b1d1b4f602c72e23eed6fbba86eefb41853a7688073fc918d912",
            "state_key_hash": "0x222b15ff81f90d75937ef6012807f0de0e0d488ccb5a229e55a954bc7870c75d",
            "data": {
                "type": "0x1::object::ObjectCore",
                "data": {
                    "allow_ungated_transfer": false,
                    "guid_creation_num": "1125899906842625",
                    "owner": "0x31deb490728ae8e1a89675ee4c1877af8e5849c526d2c9a64238c49d8ece08a0",
                    "transfer_events": {
                        "counter": "0",
                        "guid": {
                            "id": {
                                "addr": "0x60d8ef2e962b1d1b4f602c72e23eed6fbba86eefb41853a7688073fc918d912",
                                "creation_num": "1125899906842624"
                            }
                        }
                    }
                }
            },
            "type": "write_resource"
        },
        {
            "address": "0x95a0fd88b11286d4790c253b39c6678b798c54b54b63bfd2bfe042411ee2e3e8",
            "state_key_hash": "0xf389cd5138744eb2c2c40a6b708ff717cb7a04bec7c9c1b9b8847857eaf617cd",
            "data": {
                "type": "0x1::account::Account",
                "data": {
                    "authentication_key": "0x95a0fd88b11286d4790c253b39c6678b798c54b54b63bfd2bfe042411ee2e3e8",
                    "coin_register_events": {
                        "counter": "0",
                        "guid": {
                            "id": {
                                "addr": "0x95a0fd88b11286d4790c253b39c6678b798c54b54b63bfd2bfe042411ee2e3e8",
                                "creation_num": "0"
                            }
                        }
                    },
                    "guid_creation_num": "2",
                    "key_rotation_events": {
                        "counter": "0",
                        "guid": {
                            "id": {
                                "addr": "0x95a0fd88b11286d4790c253b39c6678b798c54b54b63bfd2bfe042411ee2e3e8",
                                "creation_num": "1"
                            }
                        }
                    },
                    "rotation_capability_offer": {
                        "for": {
                            "vec": []
                        }
                    },
                    "sequence_number": "1680",
                    "signer_capability_offer": {
                        "for": {
                            "vec": []
                        }
                    }
                }
            },
            "type": "write_resource"
        }
    ],
    "sender": "0x95a0fd88b11286d4790c253b39c6678b798c54b54b63bfd2bfe042411ee2e3e8",
    "sequence_number": "1679",
    "max_gas_amount": "5000",
    "gas_unit_price": "100",
    "expiration_timestamp_secs": "1760341246",
    "payload": {
        "function": "0x31deb490728ae8e1a89675ee4c1877af8e5849c526d2c9a64238c49d8ece08a0::lesserafim_3::crazy",
        "type_arguments": [
            "0x1::aptos_coin::AptosCoin",
            "0x111ae3e5bc816a5e63c2da97d0aa3886519e0cd5e4b046659fa35796bd11542a::stapt_token::StakedApt",
            "0xf22bede237a07e121b56d91a491eb7bcdfd1f5907926a9e58338f964a01b17fa::asset::USDC",
            "0x159df6b7689437016108a019fd5bef736bac692b6d4a1f10c941f6fbb9a74ca6::oft::CakeOFT",
            "0x8d87a65ba30e09357fa2edea2c80dbac296e5dec2b18287113500b902942929d::celer_coin_manager::UsdcCoin",
            "0x1::aptos_coin::AptosCoin",
            "u64",
            "u64",
            "u64",
            "u64",
            "u64"
        ],
        "arguments": [
            "0x010f0a0101",
            "0x01010101010000",
            [
                "25",
                "10",
                "30",
                "25",
                "25"
            ],
            [
                {
                    "inner": "0xa"
                },
                {
                    "inner": "0xa"
                },
                {
                    "inner": "0xa"
                },
                {
                    "inner": "0xa"
                },
                {
                    "inner": "0xa"
                },
                {
                    "inner": "0xa"
                }
            ],
            [
                "0x1",
                "0x5669f388059383ab806e0dfce92196304205059874fd845944137d96bbdfc8de",
                "0x1",
                "0x1",
                "0x1"
            ],
            [
                false,
                true,
                false,
                true,
                false
            ],
            "28452012"
        ],
        "type": "entry_function_payload"
    },
    "signature": {
        "sender": {
            "public_key": "0x1e9d94603ebd6b4a1d38e760be2b0523f09fb1f59e1e43c657f0ab3ef6205427",
            "signature": "0x05f71501658fdc40b6f42f71d6c298a378434a5825af5bc0efcc15aba2aa38625064612139299f43ae40e710bad18ce0b9935dee00b705285a8f73318f06a301",
            "type": "ed25519_signature"
        },
        "secondary_signer_addresses": [],
        "secondary_signers": [],
        "fee_payer_address": "0x31deb490728ae8e1a89675ee4c1877af8e5849c526d2c9a64238c49d8ece08a0",
        "fee_payer_signer": {
            "public_key": "0x17dfb6544cf49621c75af067528755a38061bdd210342f8bdf565bcdf561f056",
            "signature": "0x7866a52d642e7442671d0614cf7b201a29bdbd8b709ea59462d32917c368f596d771ab6592d1659952970cb277a35d536d0966a754c2cd610858f8c04eb93e08",
            "type": "ed25519_signature"
        },
        "type": "fee_payer_signature"
    },
    "replay_protection_nonce": null,
    "events": [
        {
            "guid": {
                "creation_number": "0",
                "account_address": "0x0"
            },
            "sequence_number": "0",
            "type": "0x1::transaction_fee::FeeStatement",
            "data": {
                "execution_gas_units": "130",
                "io_gas_units": "65",
                "storage_fee_octas": "0",
                "storage_fee_refund_octas": "0",
                "total_charge_gas_units": "195"
            }
        }
    ],
    "timestamp": "1760341227055115",
    "type": "user_transaction"
}

How to Build Basic-level Model-Context Protocol with GetBlock API Endpoints

A step-by-step guide on how to build MCP with GetBlock API

The Model-Context Protocol (MCP) is an open standard created by Anthropic that provides a universal way for AI assistants to connect to external data sources and tools.

With MCP, AI applications can connect to various data sources (e.g., local files, databases), tools (e.g., search engines, calculators), and workflows (e.g., specialized prompts)—enabling them to access key information and perform tasks effectively.

You can picture MCP as a "USB-C for AI":

Before USB-C: Every device had different charging ports
After USB-C: One universal port works with everything

Similarly, MCP creates a universal "port" for AI assistants to connect to data.

In short, MCP helps AI applications access the right information at the right time, thereby reducing the likelihood of incorrect or misleading responses.

In this guide, you will learn how to:

Get a GetBlock Access Token for Ethereum's API endpoint
A basic MCP server with three core capabilities:
- Check ETH balance for any Ethereum address

Prerequisites

Basic understanding of JavaScript
Must have installed and
A GetBlock

Technology Stack:

Node.js: JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.
This allows applications to provide the context for LLMs in a standardized way.
: TypeScript-first validation library.

Step 1: Project Initialization

Set up your project directory using this command:

Install Dependencies:

@modelcontextprotocol/sdk: Core MCP server functionality that provides McpServer class and transport mechanisms.
ethers: Js library for interacting with Blockchain e.g Ethereum.

Configure Package.json

"type": "module" - Enables ES6 import/export syntax (required for MCP SDK)
"main": "server.js" - Specifies entry point of your application
"bin" - Allows running server as npx mcp-ethereum

Get GetBlock's API Access Token
1. Log in to your
2. On your dashboard, scroll and click on Get Endpoint

Create the following files to have a basic structure for your project:

Step 2: Server File Setup

1. Import dependencies

Your script will be written inside server.js

What this does:

Reads API token from environment variable
Creates Ethers provider pointing to GetBlock endpoint
All blockchain queries route through GetBlock's infrastructure

3. Create MCP server instance

Configuration:

name - Unique identifier for your server
version - Semantic version for tracking updates
console.error() - Logs to stderr (separate from data output)

4. Implement Blockchain Query Tools

Tool 1: Get ETH Balance

This tool fetches the ETH balance for any Ethereum address:

What this does:

Register the tool
Validates Ethereum address format
Queries Ethereum blockchain through GetBlock

Tool 2: Get Gas Price

This tool retrieves current Ethereum gas prices:

What it does:

Register the tool
Fetch gas price
Converts the gas price from Wei to Gwei (1 Gwei = 10^9 Wei)

Tool 3: Get Block Number

This tool returns the latest Ethereum block number.

What this does:

Get the latest block
Includes server timestamp for correlation

5: Server Startup and Connection

Create a Server connection with Claude desktop

What this does:

const transport = new StdioServerTransport(): create communication channel between the client(Claude Desktop) and the server(script)
Links MCP server to transport mechanism
Registers all tools with MCP client

Start the server and shut down:

What this does:

SIGINT - Handles Ctrl+C interrupts
When the user runs npm run start , this will start the server.

Step 3: Configuration and Deployment

Open your Claude Desktop
Click on Settings
Scroll down and Click on Developer

Add the following configuration:

Config Location:

Edit Configuration:

Add the following configuration:

Config Location:

Add the following configuration:

Step 4: Testing Your Server

Test 1: Check ETH Balance

Permit Claude to query the data

Expected: Claude calls get_eth_balance tool and shows balance e.g

The ETH balance for address 0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd is 0.000104792219532 ETH (approximately 104,792,219,532,000 wei).

Test 2: Gas Price

Expected: Claude calls get_gas_price tool and shows price in Gwei e.g

The current Ethereum gas price is 0.071638489 Gwei (or about 71.6 million wei).
For EIP-1559 transactions:
Max Fee Per Gas: 0.143276976 Gwei
Max Priority Fee Per Gas: 0.000000002 Gwei
This is relatively low gas pricing, which means it's a good time for transactions on the Ethereum network.

Test 3: Block Number

Expected: Claude calls get_block_number tool and shows block e.g

The latest Ethereum block number is 23,811,857 on the Ethereum Mainnet, as of 2025-11-16 at 12:50:34 UTC.

Step 4: Advanced Tests

Test 4: Multiple Queries

Expected: Claude calls both tools and provides analysis e.g

Balance for 0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd:
0.000104792219532 ETH
Current Gas Price Assessment: The current gas price of 0.063 Gwei is very low. This is excellent for making transactions!
For context:

Test 5: Natural Language

Expected: Claude checks gas price and provides a recommendation e.g

Yes, now is an excellent time to send an Ethereum transaction! Here's why:
The current gas price of 0.060 Gwei is extremely low. To put this in perspective, a standard ETH transfer (21,000 gas units) would only cost about:
0.060 Gwei × 21,000 = 0.00000126 ETH (roughly $0.004 USD)
This is about as cheap as gas fees get on Ethereum. Gas prices can spike to 30-100+ Gwei during busy periods, which would make the same transaction 500-1600x more expensive.
However, one thing to consider: The address you checked (0xd1af...a7cd) only has 0.0001048 ETH. While the gas is cheap right now, you'd still need to ensure you're leaving enough in the wallet to cover the gas fee for any transaction you want to make.
If you're planning to send transactions from a different address with more funds, or if you're just doing something simple like a basic ETH transfer, this is definitely an opportune moment to take advantage of these low gas prices!

Troubleshooting

If you experience this error:

This means that:

Your GetBlock token is missing or incorrect
The base URL is not correct.

Each location has a unique URL

Conclusion

In this guide, you've successfully functional MCP server that connects AI assistants to blockchain data using the GetBlock API. Now you know what MCP is, how to set up your project, get your GetBlock Token and get a response directly from your Claude.

Additional Resources

How to Track Pump.fun Token Mints with GetBlock’s Yellowstone gRPC

A complete guide on how to track Pump.fun token launches on Solana in real-time using GetBlock’s Yellowstone gRPC service.

Overview

Traditional blockchain monitoring relies on polling RPC endpoints every few seconds, which introduces significant latency (2-5 seconds) and checking for updates that may not exist.

GetBlock's Yellowstone gRPC service solves this by streaming data from Solana validators in real time.

Here is a comparison:

Traditional RPC Polling

Websocket

Yellowstone gRPC

Why GetBlock’s Yellowstone gRPC?

GetBlock provides access to Solana's Yellowstone Geyser gRPC plugin, delivering real-time blockchain data through a high-performance streaming protocol:

Ultra-Low Latency: Direct streaming from validators with ~400ms latency vs 2-5 seconds with traditional RPC polling
Efficient Filtering: Subscribe only to the specific programs and accounts you need, reducing bandwidth and processing overhead
Bidirectional Streaming: Single persistent connection handles both requests and data flow, eliminating polling waste

In this guide, you will learn how to:

Connects to GetBlock's Yellowstone gRPC service
Subscribes to all transactions involving Pump.fun's program
Filters for token creation instructions specifically

Prerequisites

Before you begin, ensure you have:

and npm installed
Basic knowledge of JavaScript
A

Technology Stack:

Node.js
- Official Yellowstone gRPC client
- Base58 encoding for Solana addresses

Step 1: Set Up Your GetBlock’s Yellowstone Endpoint

Deploy Your Dedicated Solana Node

First, you need to deploy a dedicated Solana node on GetBlock with the Yellowstone gRPC add-on enabled.

1. Sign up or log in

Go to
Create an account or log in to your existing account

2. Deploy your dedicated node

Navigate to your user Dashboard
Switch to the "Dedicated nodes" tab
Scroll down to "My endpoints"

3. Enable the Yellowstone gRPC add-on

In Step 3 of your node setup (Select API and Add-ons)
Check the box for Yellowstone gRPC under Add-ons
Complete payout and finalise the setup

Generate a Yellowstone gRPC Access Token

Once your node is live, you'll create an access token to authenticate your gRPC connections.

1. Return to your dashboard

Under your dedicated node dashboard, click on "My endpoints".
Select Yellowstone gRPC
Click on Add to generate an access token

2. Your endpoint URL

You'll receive an HTTPS-style gRPC endpoint URL based on your chosen region:

Ensure you securely store both the base endpoint and the access token. You'll need them in your code to authenticate with GetBlock's Yellowstone service.

GetBlock provides a single TLS endpoint - you don't need to configure different ports or protocols. Everything works over standard HTTPS (port 443).

Step 2: Set up Development Environment

Create a directory for your project

Install Dependencies:

What these packages do:

- Official client for connecting to Yellowstone gRPC services (works with GetBlock)
- Encodes binary data to base58 format (Solana's address format). Version 5.0.0 supports vanilla js.

[email protected] because version 6.x + uses ES modules only, which don't work with vanilla js - require() statements.

Project Structure

Create the following files to have a basic structure for your project:

Step 3: Start Building Your Monitor

Import dependencies into pumpfun-monitor.js :

What this does:

yellowstone gRPC Client for connecting to GetBlock
CommitmentLevel Settings for choosing transaction confirmation speed
bs58 for converting binary data into human-readable Solana addresses.

Add your GetBlock configuration:

What this does:

Stores your GetBlock credentials.

Replace YOUR_ACCESS_TOKEN with the actual token you generated in Step 1.

If you chose a different region, use that endpoint instead (e.g., https://go.getblock.us/<ACCESS_TOKEN> or https://go.getblock.asia/<ACCESS_TOKEN>.

Add Pump.fun constants:

What this does:

PUMPFUN_PROGRAM - The unique program ID for Pump.fun on Solana
CREATE_DISCRIMINATOR - The 8-byte identifier that marks token creation instructions (derived from hashing "global:create")

Add statistics tracker:

This creates an object to track how many tokens you've detected and when the last one appeared.

Step 4: Build Data Parser Functions

Now, you'll add a function to decode the binary data from Pump.fun's instruction format.

Add string decoder:

What this does:

Pump.fun stores strings as [4 bytes for length][UTF-8 string data]. This function reads that format and returns both the string value and how many bytes were consumed.

Add Instruction Parser:
What this does:

Reads the token's metadata from Pump.fun's instruction data format. The data is organized like this:
- First 8 bytes: Discriminator (identifies this as a "create" instruction)
- Token name (e.g., "Super Doge")

The function starts at byte 8 (after the discriminator) and reads each string one by one using the decodeString helper function.

Step 5: Add Account Address Extractor

The next step is to create a function that extracts account addresses to identify newly created tokens' mint address, bonding curve pool address and creator's wallet address.

What this does:

Extracts three key addresses from the instruction:
- accounts[0] - The newly created token's mint address
- accounts[2] - The bonding curve pool address

These are defined by Pump.fun's program structure.

Step 6: Add Instruction Verifier

The next step is to verify the instruction:

What this does:

Verifies two things:
- The instruction calling Pump.fun's program
- The first 8 bytes which match the create discriminator

Only instructions passing both checks are token creations.

Step 7: Add Display Function

The next step is to add a function that displays the data in a readable format:

What this does:

Formats and displays all token information in a readable format
Updates statistics
Includes Solscan link to the token, transaction hash and creator.

Step 8: Build the Main Monitor Function

Now you'll create the core function that connects to GetBlock and processes blockchain data.

This section is broken into smaller parts for clarity.

Part A: Start the Function and Connect

What this does:

Creates a client connection to GetBlock using your credentials and opens a bi-directional streaming connection.

Part B: Configure Subscription

What this does:

Tells GetBlock you only want transactions involving Pump.fun's program, with CONFIRMED commitment level (~2-3 seconds, balanced speed/reliability).

Part C: Handle Incoming Data

What this does:

Processes each message from GetBlock - responds to keep-alive pings and extracts transaction data.

Part D: Process Instructions

What this does:

For each instruction, it checks if it's a create, parses metadata, extracts addresses, and displays results.

Part E: Handle Errors

What this does:

It handles stream errors and connection closures.

Part F: Send Request

What this does:

Sends your subscription request to GetBlock and confirms the connection is active.

This completes the monitorPumpfunMints() function - everything above is part of this one function in your pumpfun-monitor.js file.

Step 9: Add Execution Code

Finally, add the code to run your monitor:

What this does:

Runs your monitor and automatically restarts it if it crashes.

What this does:

Handles Ctrl+C to show final statistics before shutdown.

Step 10: Run Your Monitor

Run the following command in your terminal to start the server:

Expected Output

You'll see:

This means you're connected to GetBlock and monitoring is active.

When a Token Appears

When a new token appears, it displays like this:

Congratulations 🎉, you've successfully created an application that tracks Pump.fun token minted.

Troubleshooting

Connection issues:

This means there is a connection glitch:

Verify your ENDPOINT and TOKEN in pumpfun-monitor.js
Check your GetBlock dashboard to confirm if the node is active
Test your internet connection

Tokens not showing:

Be patient - Pump.fun typically has 50-200 tokens per day
Visit to verify tokens are being created
Try CommitmentLevel.PROCESSED for faster updates

Parser Errors:

These warnings are normal. This means some transactions aren't structured.

Security Best Practices

This is highly recommended to use environment variables instead of hard-coding. Create an .env file and store your token like this:

and reference it in your pumpfun-monitor.js like this:

Remember to add the .env file in your .gitignore file.

Conclusion

In this guide, you learn how to build a tracking application that monitors Pump.fun token minted using GetBlock Yellowstone gRPC. This guide explains the importance of using GetBlock Yellowstone gRPC, how to get your Yellowstone gRPC token, set up the application to get the expected result.

It also explains how to troubleshoot some errors you may encounter and possible ways to enhance the security and maintainability of your applications.

Additional Resources

How to Listen to High-Value SOL Transactions via Yellowstone Geyser gRPC with GetBlock

How to Build an App to Track Large Solana Transactions with GetBlock Yellowstone Geyer gRPC

Monitoring high-value SOL transactions is essential for understanding the dynamics of the Solana network. By using tools like Yellowstone Geyser gRPC with GetBlock, developers can gain real-time insights into significant financial movements, enabling them to make informed decisions and capitalize on trends within the Solana ecosystem.

In this tutorial, you'll build a monitoring app that detects high-value SOL transfers the moment they occur on the Solana blockchain.

You'll learn how to:

Connect to GetBlock's Yellowstone gRPC service for ultra-low latency blockchain data streaming
Subscribe to Solana's System Program to capture all native SOL transfers
Parse transfer instruction data to extract amounts, sender addresses, and recipient addresses
Filter transactions based on transfer amount thresholds
Display real-time alerts with formatted output and explorer links
Track statistics, including total volume and largest transfers

Technology Stack:

Node.js
- Official Yellowstone gRPC client
- Base58 encoding for Solana addresses

Prerequisites

Before you begin, ensure you have:

Node.js v18 or higher is installed on your system
Basic JavaScript knowledge
A GetBlock account - Free sign-up available at getblock.io

Step 1: Set Up Your GetBlock Yellowstone Endpoint

Deploy Your Dedicated Solana Node

First, you need to deploy a dedicated Solana node on GetBlock with the Yellowstone gRPC add-on enabled.

1. Sign up or log in

Go to GetBlock
Create an account or log in to your existing account

2. Deploy your dedicated node

Navigate to your user Dashboard
Switch to the "Dedicated nodes" tab
Scroll down to "My endpoints."

3. Enable the Yellowstone gRPC add-on

In Step 3 of your node setup (Select API and Add-ons)
Check the box for Yellowstone gRPC under Add-ons
Complete payout and finalize the setup

Generate Your gRPC Access Token

Once your node is live, you'll create an access token to authenticate your gRPC connections.

1. Return to your dashboard

Go to "My endpoints" in your Dedicated node dashboard and generate a gRPC Access Token

2. Your endpoint URL

You'll receive an HTTPS-style gRPC endpoint URL based on your chosen region:

Save both pieces of information:

Base Endpoint: https://go.getblock.io (or your region)
Access Token: The alphanumeric token generated

Step 2: Initialize Your Project

Open your terminal and create a new directory:

Initialize Node.js Project

Install the required packages:

Create a new file:

Configure package.json:

"type": "module" - Enables ES6 import/export syntax (required for modern JavaScript)
"main": "sol-transfer-monitor.js" - Specifies the entry point of your application
"scripts" - Defines shortcuts like

Project Structure

Create the following files to have a basic structure for your project:

Create a .gitignore file:

Step 3: Start Building Your Monitor

You'll build everything in a single file called sol-transfer-monitor.js.

Import Dependencies

What this does:

Client - The main class for establishing a connection to GetBlock's Yellowstone gRPC service
CommitmentLevel- Configuration options that determine how finalized transactions should be before you receive them (PROCESSED = fastest but can be rolled back, CONFIRMED = balanced, FINALIZED = slowest but guaranteed)
bs58

Add Your GetBlock Configuration

What this does: Stores your GetBlock credentials for authenticating your connection.

If you chose a different region during setup, use that base URL instead (e.g., https://go.getblock.us or https://go.getblock.asia).

Add Solana System Program Constants

What this does:

SYSTEM_PROGRAM - This is the unique identifier for Solana's built-in System Program, which is responsible for all native SOL transfers on the network. Every time someone sends SOL from one wallet to another, this program processes it.
MIN_TRANSFER_AMOUNT - Sets the threshold for what qualifies as a "high-value" transfer. Only transfers of 100 SOL or more will trigger an alert. You can adjust this to any amount (e.g., 50 SOL, 1000 SOL, etc.).

Add Statistics Tracker

What this does:

Creates an object to track key metrics about the transfers you're monitoring. It records:
- When the monitor started
- How many high-value transfers have been detected

Step 4: Build Utility Functions

Now you'll add helper functions to format data and display results.

Add SOL Formatter

What this does:

Converts lamports (Solana's smallest unit) to SOL for human-readable display. Solana stores all amounts in lamports, where 1 SOL equals 1 billion lamports (similar to how 1 Bitcoin = 100 million satoshis). This function divides by 1 billion and rounds to 4 decimal places, so 5,500,000,000 lamports becomes "5.5000 SOL".

Add Display Function

What this does:

Formats and displays all transfer information clearly. It first updates your running statistics (incrementing the transfer count, adding to total volume, and checking if this is the largest transfer seen).
Then it converts the amount from lamports to SOL and prints out all the details, including sender, recipient, transaction signature, and slot number.
Finally, it includes clickable Solscan explorer links so you can investigate the transaction, sender, and recipient in more detail.

Step 5: Build the Transfer Parser

Now you'll create the function that extracts transfer details from instruction data.

Add Transfer Instruction Parser

What this does:

Extracts the transfer amount and account addresses from a System Program instruction.

If anything goes wrong during parsing (malformed data, missing accounts, etc.), it catches the error and returns null.

Step 6: Build the Main Monitor Function

Now you'll create the core function that connects to GetBlock and processes blockchain data.

Part A: Start the Function and Connect

What this does:

Initializes the monitor by displaying startup information and establishing a connection to GetBlock.
Creates a new Client instance using your endpoint and token, then opens a bidirectional streaming connection.
The subscribe() method returns a stream object that handles both sending requests to GetBlock and receiving blockchain data.

Part B: Configure Subscription

What this does:

Builds the subscription request that tells GetBlock exactly what blockchain data you want to receive.
- It filters sol_transfers
- Send transactions that interact with the system

Part C: Handle Incoming Data

What this does:

Sets up an event handler that processes every message GetBlock sends through the stream.

Part D: Process Instructions

What this does:

Loops through each instruction in the transaction to find and process SOL transfers.

Part E: Handle Stream Events

What this does:

Sets up handlers for stream connection issues.
If the stream encounters an error (network problem, authentication issue, etc.), it logs the error message and rejects the Promise, which will trigger the auto-restart logic in the main() function.
The "end" and "close" events indicate the stream has been terminated gracefully, so it resolves the Promise normally.

Part F: Send Subscription Request

What this does:

Send your subscription request to GetBlock to activate the stream.
Once the request is sent successfully, it confirms that monitoring is active.
The callback function checks if there was an error sending the request - if so, it rejects the Promise; otherwise, it displays a success message. This completes the monitorHighValueTransfers() function.

Step 7: Add Execution Code

Finally, add the code to run your monitor and handle shutdown.

Add Main Execution Function

What this does:

Wraps your monitor in an auto-restart loop. If the monitor crashes for any reason (network disconnection, API error, unexpected data format), it catches the error, displays an error message, waits 5 seconds, and then automatically restarts the monitor. This ensures your monitor keeps running even if temporary issues occur.

Add Shutdown Handler

What this does:

Handles shutdown when you press Ctrl+C or cmd+C. Instead of abruptly terminating, it displays a summary of your monitoring session, including total transfers detected, cumulative volume, the largest transfer amount with a link to view it, and how long the monitor was running. Then it cleanly exits the process.

Start the Monitor

What this does:

Run everything. This is the last line of your sol-transfer-monitor.js file and triggers the execution of your monitor.

TestStep 8: Tets Your Monitor

1. Start the Monitor

Expected Output:

Troubleshooting

Permission denied:

This means that your access token is missing or incomplete, or you are using the wrong Base URL.

2. No Transfers Showing

High-value transfers (100+ SOL) are less common than you might expect
Try lowering MIN_TRANSFER_AMOUNT to 10 or 50 SOL to see more activity
Use CommitmentLevel.PROCESSED for faster updates (though some may be rolled back)

Conclusion

In this guide, you've learnt how to build a monitor app that tracks high-value SOL transactions on Solana networks. It shows you the steps involved, such as:

Connects to GetBlock's Yellowstone gRPC service
Streams blockchain data with ~400ms latency
Filters for System Program transactions

Additional Resources

How to Monitor Liquidity Pools on Solana DEXes with GetBlock's Yellowstone gRPC

Step-by-step guide for building a Node.js app to track real-time swaps on Solana using GetBlock's Yellowstone gRPC

Monitoring liquidity pools on Solana decentralised exchanges (DEXes) in real-time is crucial for traders and developers who want to stay updated with the latest market conditions and make informed decisions.

GetBlock's Yellowstone gRPC service allows developers to fetch data directly from Solana validators easily with low latency - appropriately ~400ms latency.

In this guide, you'll build a monitor that tracks every swap happening on a specific Solana DEX liquidity pool, regardless of which platform (Jupiter, Raydium, Phantom Wallet, etc.) the user is trading with.

You'll learn how to:

Connect to GetBlock's Yellowstone gRPC service for ultra-low latency blockchain data streaming
Subscribe to transactions involving specific liquidity pool addresses
Filter out failed transactions to show only successful swaps
Identify which DEX or aggregator initiated each swap (Jupiter, Raydium, etc.)
Display real-time swap alerts with formatted output and explorer links
Track comprehensive statistics about trading activity

Prerequisites

Before you begin, ensure you have:

and npm installed
Basic knowledge of JavaScript
A

Technology Stack:

Node.js
- Official Yellowstone gRPC client
- Base58 encoding for Solana addresses

Step 1: Set Up Your GetBlock’s Yellowstone Endpoint

Deploy Your Dedicated Solana Node

First, you need to deploy a dedicated Solana node on GetBlock with the Yellowstone gRPC add-on enabled.

1. Sign up or log in

Go to
Create an account or log in to your existing account

2. Deploy your dedicated node

Navigate to your user Dashboard
Switch to the "Dedicated nodes" tab
Scroll down to "My endpoints"

3. Enable the Yellowstone gRPC add-on

In Step 3 of your node setup (Select API and Add-ons):

Check the box for Yellowstone gRPC under Add-ons
Complete payout and finalize the setup

Generate a Yellowstone gRPC Access Token

Once your node is live, you'll create an access token to authenticate your gRPC connections.

1. Return to your dashboard

Under your dedicated node dashboard, click on "My endpoints".
Select Yellowstone gRPC
Click on Add to generate an access token

2. Your endpoint URL

You'll receive an HTTPS-style gRPC endpoint URL based on your chosen region:

Ensure you securely store both the base endpoint and the access token. You'll need them in your code to authenticate with GetBlock's Yellowstone service.

Step 2: Set up Development Environment

Create a directory for your project

Install Dependencies:

What these packages do:

- Official client for connecting to Yellowstone gRPC services (works with GetBlock)
- Encodes binary data to base58 format (Solana's address format). Version 5.0.0 supports vanilla js.

[email protected] because version 6.x + uses ES modules only, which don't work with vanilla js - require() statements.

Configure Package.json

"type": "module" - Enables ES6 import/export syntax
"scripts" - Defines shortcuts like npm start

Project Structure

Create the following files to have a basic structure for your project:

Step 3: Start Building Your Monitor

You'll build everything in a single file called pool-monitor.js. Let's start creating it piece by piece.

Import Dependencies

Create a new file pool-monitor.js and add:

What this does:

Client- The main class you'll use to connect to GetBlock's Yellowstone gRPC service and create a streaming connection
CommitmentLevel - Solana has different levels of transaction finality (how "confirmed" a transaction is). You'll use this to choose how finalised you want transactions to be before receiving them
bs58

Add Your GetBlock Configuration

What this does:

Stores your GetBlock credentials that you created in Replace YOUR_ACCESS_TOKEN with the actual token you generated. If you chose a different region, use that endpoint instead (e.g., https://go.getblock.us or https://go.getblock.asia).

Add Pool Configuration

What this does:

TARGET_POOL - The unique address of the liquidity pool you're monitoring. This is the SOL/USDC Concentrated Liquidity pool on Raydium, one of the most active trading pools on Solana, with over 140,000 transactions per day
POOL_NAME - A human-readable name for display purposes

Add DEX Program IDs

What this does:

Stores the unique program IDs for major Solana DEX platforms. These are like addresses for the programs (smart contracts) themselves. When someone makes a swap, their transaction calls one of these programs. By checking which program was called, you can identify if the swap came from:
- Raydium_AMM - Raydium's standard automated market maker
- Raydium_CLMM

Add Statistics Tracker

What this does:

It creates a simple object to track two key pieces of information: when the monitor was started (startTime) and the total number of successful swaps detected (totalSwaps).
This allows you to view cumulative statistics when you stop the program.

Step 4: Build the Swap Source Identifier

Now you'll add a function to identify which platform initiated each swap.

What this does:

This function examines all the instructions in a transaction to figure out where the swap came from.

Understanding how this works:

Every Solana transaction contains one or more "instructions" - think of these as individual commands or steps
Each instruction calls a specific program (smart contract)
The programIdIndex points to which program being called

Why this matters:

Users don't always trade directly on Raydium. They might use Jupiter (which finds the best price by checking multiple DEXes) or their wallet's built-in swap feature. This function shows you the actual entry point the user used, which is interesting for understanding trading patterns.

Step 5: Add Display Function

What this does:

Formats and displays each swap in a readable way to your terminal.

Break down:

stats.totalSwaps++ - Increments the counter every time we display a swap
"=".repeat(80) - Creates a visual separator line (80 equal signs)
SOURCE - Shows which platform was used (Jupiter, Raydium, etc.)

Why formatted output matters:

Raw blockchain data is hard to read. This function turns binary data and hex strings into useful information that helps you understand what's happening.

Step 6: Build the Main Monitor Function

Now you'll create the core function that connects to GetBlock and processes blockchain data.

This is broken into smaller parts for clarity.

Part A: Start the Function and Connect

What this does:

Prints a startup message so you know the monitor is launching
Creates a Promise so this function can run asynchronously and handle errors properly
new Client(ENDPOINT, TOKEN, undefined)- Creates a connection client using your GetBlock credentials.

Unlike making individual API requests (like asking "what's new?" every few seconds), this creates a persistent stream. GetBlock will push data to you immediately as it happens on the blockchain.

Part B: Configure Subscription

What this does:

Tells GetBlock exactly what data you want to receive

Part C: Handle Incoming Data

What this does:

Sets up an event listener that processes each message GetBlock sends you.

Part D: Process and Display Swaps

What this does:

processes each transaction and:
- Checks if the transaction failed - txMeta.err will be present if the transaction failed. We skip these because failed swaps aren't useful to track (they might be due to slippage, insufficient balance, etc.)
- Identifies the source - Calls our identifySwapSource() function to determine if it came from Jupiter, Raydium, or elsewhere

Part E: Handle Stream Events

What this does:

Handles different connection states such as:
- error - If something goes wrong with the connection (network issue, GetBlock problem, etc.), we log the error and reject the Promise. This will trigger our auto-reconnect logic later
- end - The stream ended gracefully (normal shutdown)

Both end and close resolve the Promise, which allows the program to shut down cleanly or restart if needed.

Part F: Send Subscription Request

What this does:

Sends your subscription configuration to GetBlock and confirms the connection is active.

At this stage, your monitor is fully connected, subscribed, and waiting for swaps. Every time someone trades on the SOL/USDC pool through any platform, you'll receive the data within ~400ms and display it.

Step 7: Add Auto-Restart Functionality

Add the code to run your monitor with automatic restart on errors:

What this does:

Provides resilience by automatically restarting if something goes wrong.

This ensures your monitor keeps running even if there's a temporary problem. In production, you'd want to add limits (don't restart forever if there's a permanent issue), but this is great for getting started.

Step 8: Add Shutdown

Finally, add the code to handle Ctrl+C successfully:

Step 9: Test Your Monitor

Run the Monitor

Expected output:

You'll see:

What you see:

SOURCE- This swap came through Jupiter's aggregator
TRADER - The wallet address that made the swap
SIGNATURE - Unique transaction ID (click the link to see full details on Solscan)

The SOL/USDC pool typically has 140,000+ swaps per day, so you should see activity within seconds of starting the monitor.

Troubleshooting

Connection Issues:

Verify your ENDPOINT and TOKEN in pool-monitor.js
Check your GetBlock dashboard, confirm the node is active
Test your internet connection

No Swaps Showing:

If you don't see any swaps after a minute:

The SOL/USDC pool is extremely active, so this is unusual
Try visiting to verify it's active
Check that your subscription was successful (you should see "✅ Subscription active")

Processing Errors:

These are normal. Occasionally, some transactions have non-standard formats
Your monitor will skip these and continue running
Failed transactions are automatically filtered out

Conclusion

In this guide, you've learn how to build a monitor that fetches liquidity pools on Solana DEXes with GetBlock's Yellowstone gRPC. This guide exposes you to the importance of using GetBlock's Yellowstone gRPC and how to set up the project effectively.

Resources:

How to Build Pump.fun to PumpSwap and Raydium Migrations Listener with GetBlock

A step-by-step guide on how to build a real-time listener for Pump.fun token migrations to both PumpSwap and Raydium using GetBlock API

Pump.fun is a Solana-based memecoin launchpad that uses a bonding curve mechanism to initiate token distribution. When a token reaches an approximate market cap of $69,000, it graduates from the bonding curve. At this point, $12,000 of liquidity is deposited to either Raydium DEX or PumpSwap (Pump.fun's native DEX). This migration creates immediate trading opportunities for developers and traders who can detect these events in real-time.

March 2025, Pump.fun introduced PumpSwap, her own decentralized exchange. Since then, most tokens have migrated to PumpSwap instead of Raydium. This guide will show you how to track migrations to both destinations.

How Pump.fun Migrations Work

Tokens on Pump.fun start trading on a bonding curve mechanism. When the bonding curve reaches completion (approximately $69,000 market cap), the protocol executes a migration.

Migration Flow:

Bonding Curve Phase: Token trades on Pump.fun using bonding curve pricing
Completion Trigger: Bonding curve reaches ~$69k market cap
Migration Transaction: Pump.fun migration account executes the migration

Key Addresses

Program

Address

The Pump.fun migration account manages both types of migrations.

For PumpSwap migrations, it calls migrate instruction on the Pump.fun program.

In this guide, you will learn how to:

Get a GetBlock Access Token for Solana's API endpoint
Build a WebSocket listener that detects Pump.fun migrations to both PumpSwap and Raydium
Process transaction logs to extract token and pool information

Prerequisites

Basic understanding of JavaScript
A GetBlock
Node.js installed (v18 or higher)

Technology Stack

Node.js: JavaScript runtime environment for building server applications
Official Solana JavaScript SDK for blockchain interactions
: WebSocket client library for real-time connections

Step 1: Project Initialization

Set up your project directory using this command:

Install Dependencies:

Configure package.json:

"type": "module" - Enables ES6 import/export syntax (required for modern JavaScript)
"main": "server.js" - Specifies entry point of your application
"scripts" - Defines shortcuts like

Get GetBlock's API Access Token

Log in to your
On your dashboard, scroll and click on Get Endpoint
Select the Solana Mainnet network

Your WebSocket endpoint will look like:

Also get the HTTP endpoint for transaction fetching:
- Return to the dashboard
- Select JSON-RPC (https://) under API Interface

Your HTTP endpoint will look like:

Save both endpoints in a .env file in your project root:

Keep your endpoints safe, as they contain your access token

Project Structure

Create the following files to have a basic structure for your project:

Create a .gitignore file:

Step 2: Server File Setup

Your script will be written inside server.js

1. Import Dependencies and Configuration

What this does:

Imports necessary libraries for Solana interactions and WebSocket connections
Loads API endpoints securely from environment variables
Validates that the required configuration is present

2. Create the Migration Listener Class

Breaking down the constructor:

The constructor initializes all the state we need to track. Let me explain each property:

this.ws - Will hold our WebSocket connection to GetBlock
this.connection - HTTP connection for fetching full transaction details
this.subscriptionId - The ID returned when we subscribe to logs

3. Create an Interval check

What this does:

The start() method kicks everything off. It checks if the Websocket is connected or not.
The checkRunning() method creates a timer that runs every 60 seconds (60000 milliseconds). This serves two purposes:
1. It shows the listener is still running

Migration isn't frequent and may not occur within an hour. This is good for debugging—if no logs appear, it's a sign there's an issue with the subscription. This ensures that monitoring is active.

4. Create GetBlock Websocket Connection

What this does:

The connect() method creates a new WebSocket connection to GetBlock. Then it sets up four event listeners:
- open - Called when the connection is established
- message

What this does:

Uses Solana's logsSubscribe method to monitor transactions
Filters for transactions mentioning the Pump.fun migration account
Uses confirmed commitment for faster notifications (1-2 seconds)

6. Handle Incoming Messages

What this does:

Parses incoming WebSocket messages
Handles subscription confirmation and stores subscription ID
Processes log notifications for migration detection

7. Process Transaction Logs

What this does:

Checks transaction logs for migration keywords like:
Skips failed transactions
Fetches full transaction details when migration is detected

8. Fetch Full Transaction Details

What this does:

Waits 1 second for the transaction to propagate
Fetches complete transaction from Solana via HTTP
Extracts and displays migration data

9. Extract Migration Data

What this does:

Handles both versioned and legacy Solana transactions
Detects Raydium migrations by checking for Raydium program ID
Detects PumpSwap migrations by checking for Pump.fun program ID

10. Display Migration Results

What this does:

Displays Raydium migrations with pool and LP mint info
Displays PumpSwap migrations with bonding curve info
Provides links to Solscan and trading platforms

11. Handle Reconnections

What this does:

Implements exponential backoff for reconnections (2s, 4s, 8s, etc.)
Caps reconnection delay at 30 seconds
Exits after 10 failed reconnection attempts

12. Initialize and Run

What this does:

Handles graceful shutdown on Ctrl+C
Catches uncaught errors

Step 4: Testing Your Listener

Start your migration listener:

Expected Output:

Test 1: Real-time PumpSwap Migration

When a token migrates to PumpSwap:

Test 2: Real-time Raydium Migration

When a token migrates to Raydium (rare):

Test 3: Check if alive

Every minute:

Troubleshooting

1. Missing access token or Connection error

This means that:

You haven't set up your environment variable as follows in this guide
Your Access token is incorrect or incomplete

2. Only seeing PumpSwap migrations or no migration at all

This is expected. Since March 2025, most tokens (95%+) have migrated to PumpSwap instead of Raydium. Also, migration doesn't happen frequently.

Not receiving any logs

Solution:

Verify subscription succeeded (you should see ✅ Subscribed with ID)
Check GetBlock dashboard for API usage limits
Verify transactions exist at

Conclusion

In this guide, you've built an app that listens to Pump.fun token migrations to both PumpSwap and Raydium using GetBlock's Solana infrastructure. You learn:

How to connect to GetBlock's WebSocket API for real-time blockchain data
How to subscribe to specific account activities on Solana
How to distinguish between PumpSwap and Raydium migrations

Additional Resources

How To Build a Base Flashblocks Listener

A step-by-step guide to subscribing to Base Flashblocks and building trading applications around ultra-fast blockchain data.

Traditional blockchain confirmations are slow. On Ethereum Layer 2 networks, such as Base, blocks are produced every 2 seconds. While this is already faster than Ethereum's ~12-second blocks, it's still an eternity for time-sensitive applications like trading bots, real-time games, or DeFi protocols where milliseconds matter.

Flashblocks break the limitation of traditional blocks by creating mini-blocks every 200 milliseconds, providing users with instant transaction status while still retaining cryptographic security.

In this guide, you'll learn what base flashblocks are, their importance, data structure and step-by-step instructions on how to build a base flashblocks listener.

What Are Base Flashblocks?

Flashblocks are sub-blocks (or "mini-blocks") streamed every 200 milliseconds — that's 10x faster than Base's standard 2-second block time. Developed in collaboration with Flashbots and launched on Base Mainnet in July 2025, Flashblocks provide preconfirmations: ultra-fast signals that arrive before the next full block is sealed.

Here's how it works:

Standard Base blocks: Created every 2 seconds, containing all transactions
Flashblocks: 10 sub-blocks per full block, streamed every 200ms
Each Flashblock contains ~10% of the transactions (by gas) of a regular block

Think of it like texting vs. email. Traditional blocks are like writing an entire email, proofreading it, and hitting send. Flashblocks are like texting — you send each line instantly and keep going.

Importance of Flashblocks for Trading

For trading applications, Flashblocks unlock several critical advantages:

Near-instant transaction feedback: Know within 200ms if your transaction was included
Front-running prevention: Once a Flashblock is built and broadcast, its transaction ordering is locked. Later-arriving transactions with higher fees can't jump ahead
Real-time state updates: See balance changes, liquidity shifts, and price movements as they happen

What You're Building

In this tutorial, you'll build a Go application that:

Connects to the Base Flashblocks WebSocket stream
Handles both plain JSON and Brotli-compressed messages
Parses Flashblock data structures (transactions, receipts, balance updates)

This forms the foundation for building trading bots, monitoring tools, or any application that needs ultra-low-latency blockchain data.

Understanding the Flashblock Data Structure

Before diving into code, let's understand what data you'll receive. Each Flashblock message contains three main components:

1. The Root Structure

The Index field tells you which of the 10 Flashblocks within a full block you're receiving (0 through 9).

2. BlockDiff — The Block Changes

Key fields for trading applications:

Transactions: Array of raw transaction data included in this Flashblock
StateRoot: Cryptographic proof of the blockchain state after these transactions

3. Metadata — Balances and Receipts

This is where the trading gold is:

BlockNumber: The full block number this Flashblock belongs to
NewAccountBalances: Map of addresses to their updated ETH balances

4. Receipts — Transaction Results

Receipts come in two flavors: EIP-1559 (modern) and Legacy. The Logs array contains event emissions — crucial for detecting swaps, transfers, and other contract events.

Prerequisites

Before we begin, make sure you have:

Go 1.21+ installed ()
Basic understanding of WebSockets and blockchain concepts
A terminal/command line environment

Dependencies

This application uses two external packages:

(Flashblocks are compressed)

Project Setup

Create a new directory for your project and initialize the Go module:

Install the required dependencies:

Your go.mod file should look like this:

Building the Listener

Create main.go and start with the package and imports:

This imports standard library packages for JSON handling, logging, and signal management, plus our two external dependencies.

Define WebSocket endpoints and the data structures described earlier:

Now define all the data structures:

The GetData() and GetType() helper methods on Receipt let us work with receipts without worrying about whether they're EIP-1559 or Legacy format.

Implement the main routine: flag parsing, selecting the endpoint, connecting via WebSocket, and setting up message processing and graceful shutdown.

This covers:

Flag parsing for -network
WebSocket connection via gorilla/websocket
Signal handling for graceful shutdown

Flashblock messages are typically Brotli-compressed. Decompress them with:

Unmarshal JSON into structs and print a readable summary.

Pretty-print the flashblock:

This output shows:

Flashblock index (0-9)
Block number and hash
Gas usage and roots
Transaction list (truncated hashes)

Running the Listener

1. Build and Run

Expected Output

When running, you'll see Flashblocks streaming in real-time:

You'll see new Flashblocks appear approximately every 200 milliseconds.

Shutting Down

Press Ctrl+C to stop the listener. It will send a proper WebSocket close message before exiting:

Extending for Trading Applications

Now that you have the basic listener working, here are some ways to extend it for trading:

1. Filter Transactions by Address

Monitor specific addresses (your wallet, a DEX router, etc.):

2. Detect Swap Events

Watch for Uniswap V2/V3 swap events by checking the first topic (event signature):

3. Track Balance Changes

Monitor when specific addresses receive or send ETH:

Important Considerations

Preconfirmation vs. Finality

Flashblocks provide preconfirmations, not final confirmations. While extremely reliable, there's a small chance (during rare reorgs) that a Flashblock's data might differ from the final block.

For critical transactions:

Use Flashblocks for fast UI feedback
Wait for full block confirmation for settlement

Rate Limits

The public endpoints (wss://mainnet.flashblocks.base.org/ws) are rate-limited. For production applications:

Use a node provider () with Flashblocks support
Consider running your own Flashblocks-aware node

Handling Disconnections

In production, add reconnection logic:

Complete Code

Here's the full main.go file:

Full Code

Conclusion

You've built a real-time Base Flashblocks listener in Go that:

Connects to the Flashblocks WebSocket stream
Handles Brotli-compressed messages
Parses and displays transaction data, receipts, and balance updates

Resources

main.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"os/signal"
	"syscall"

	"github.com/andybalholm/brotli"
	"github.com/gorilla/websocket"
)

const (
	mainnetWSURL = "wss://mainnet.flashblocks.base.org/ws"
	sepoliaWSURL = "wss://sepolia.flashblocks.base.org/ws"
)

// Flashblock represents the root structure of a flashblock message
type Flashblock struct {
	Diff     BlockDiff `json:"diff"`
	Index    int       `json:"index"`
	Metadata Metadata  `json:"metadata"`
}

// BlockDiff contains the block differences/updates
type BlockDiff struct {
	BlobGasUsed     string   `json:"blob_gas_used"`
	BlockHash       string   `json:"block_hash"`
	GasUsed         string   `json:"gas_used"`
	LogsBloom       string   `json:"logs_bloom"`
	ReceiptsRoot    string   `json:"receipts_root"`
	StateRoot       string   `json:"state_root"`
	Transactions    []string `json:"transactions"`
	Withdrawals     []any    `json:"withdrawals"`
	WithdrawalsRoot string   `json:"withdrawals_root"`
}

// Metadata contains block metadata including balances and receipts
type Metadata struct {
	BlockNumber        uint64             `json:"block_number"`
	NewAccountBalances map[string]string  `json:"new_account_balances"`
	Receipts           map[string]Receipt `json:"receipts"`
}

// Receipt represents a transaction receipt (can be EIP-1559 or Legacy)
type Receipt struct {
	Eip1559 *ReceiptData `json:"Eip1559,omitempty"`
	Legacy  *ReceiptData `json:"Legacy,omitempty"`
}

// GetData returns the receipt data regardless of type
func (r *Receipt) GetData() *ReceiptData {
	if r.Eip1559 != nil {
		return r.Eip1559
	}
	return r.Legacy
}

// GetType returns the receipt type as a string
func (r *Receipt) GetType() string {
	if r.Eip1559 != nil {
		return "EIP-1559"
	}
	if r.Legacy != nil {
		return "Legacy"
	}
	return "Unknown"
}

// ReceiptData contains the actual receipt information
type ReceiptData struct {
	CumulativeGasUsed string `json:"cumulativeGasUsed"`
	Logs              []Log  `json:"logs"`
	Status            string `json:"status"`
}

// Log represents an event log
type Log struct {
	Address string   `json:"address"`
	Data    string   `json:"data"`
	Topics  []string `json:"topics"`
}

func main() {
	network := flag.String("network", "mainnet", "Network to connect to: mainnet or sepolia")
	flag.Parse()

	var wsURL string
	switch *network {
	case "mainnet":
		wsURL = mainnetWSURL
	case "sepolia":
		wsURL = sepoliaWSURL
	default:
		log.Fatalf("Invalid network: %s. Use 'mainnet' or 'sepolia'", *network)
	}

	log.Printf("Connecting to Base flashblocks on %s: %s", *network, wsURL)

	conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
	if err != nil {
		log.Fatalf("Failed to connect to WebSocket: %v", err)
	}
	defer conn.Close()

	log.Println("Connected! Listening for flashblocks...")

	// Handle graceful shutdown
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	done := make(chan struct{})

	go func() {
		defer close(done)
		for {
			messageType, message, err := conn.ReadMessage()
			if err != nil {
				if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
					log.Println("WebSocket closed normally")
					return
				}
				log.Printf("Error reading message: %v", err)
				return
			}

			switch messageType {
			case websocket.TextMessage:
				handleFlashblockJSON(message)
			case websocket.BinaryMessage:
				decoded, err := decodeBrotli(message)
				if err != nil {
					log.Printf("Error decoding Brotli: %v", err)
					log.Printf("Raw binary message length: %d bytes", len(message))
					continue
				}
				handleFlashblockJSON(decoded)
			default:
				log.Printf("Received unknown message type: %d", messageType)
			}
		}
	}()

	select {
	case <-done:
		log.Println("Connection closed")
	case sig := <-sigChan:
		log.Printf("Received signal %v, shutting down...", sig)
		err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
		if err != nil {
			log.Printf("Error sending close message: %v", err)
		}
	}
}

func decodeBrotli(data []byte) ([]byte, error) {
	reader := brotli.NewReader(bytes.NewReader(data))
	return io.ReadAll(reader)
}

func handleFlashblockJSON(data []byte) {
	var flashblock Flashblock
	if err := json.Unmarshal(data, &flashblock); err != nil {
		log.Printf("Error parsing flashblock JSON: %v", err)
		log.Printf("Raw data: %s", string(data))
		return
	}

	printFlashblock(&flashblock)
}

func printFlashblock(fb *Flashblock) {
	fmt.Println("═══════════════════════════════════════════════════════════════")
	fmt.Printf("FLASHBLOCK #%d | Block: %d | Hash: %s\n",
		fb.Index,
		fb.Metadata.BlockNumber,
		truncateHash(fb.Diff.BlockHash))
	fmt.Println("═══════════════════════════════════════════════════════════════")

	fmt.Printf("  Gas Used:       %s\n", fb.Diff.GasUsed)
	fmt.Printf("  Blob Gas Used:  %s\n", fb.Diff.BlobGasUsed)
	fmt.Printf("  State Root:     %s\n", truncateHash(fb.Diff.StateRoot))
	fmt.Printf("  Receipts Root:  %s\n", truncateHash(fb.Diff.ReceiptsRoot))

	fmt.Printf("\n  Transactions: %d\n", len(fb.Diff.Transactions))
	for i, tx := range fb.Diff.Transactions {
		fmt.Printf("    [%d] %s...\n", i, truncateHash(tx))
	}

	fmt.Printf("\n  Account Balance Updates: %d\n", len(fb.Metadata.NewAccountBalances))

	fmt.Printf("\n  Receipts: %d\n", len(fb.Metadata.Receipts))
	receiptCount := 0
	for txHash, receipt := range fb.Metadata.Receipts {
		if receiptCount >= 3 {
			fmt.Printf("    ... and %d more receipts\n", len(fb.Metadata.Receipts)-3)
			break
		}
		data := receipt.GetData()
		if data != nil {
			fmt.Printf("    [%s] %s - Status: %s, Logs: %d\n",
				receipt.GetType(),
				truncateHash(txHash),
				data.Status,
				len(data.Logs))
		}
		receiptCount++
	}

	fmt.Println()
}

func truncateHash(hash string) string {
	if len(hash) <= 20 {
		return hash
	}
	return hash[:10] + "..." + hash[len(hash)-8:]
}

How to Build a Pay-Per-Request Blockchain API With x402 and GetBlock

Build a pay-per-request blockchain data API using the x402 protocol and GetBlock's node infrastructure.

Overview

The x402 protocol is an open payment method that enables developers and service providers to charge for and sell their APIs and content via HTTP without requiring third-party integrations, credential setup, or gas fees.

The x402 protocol brings the HTTP 402 "Payment Required" status code to life. Originally reserved in the HTTP specification for future use with digital payments, x402 finally implements this vision, enabling micropayments to be made directly over HTTP.

How it works

Frank adds "payment required" to his API endpoints
His client requests a protected resource,
The server responds with 402 Payment Required along with payment details.

All of this happens in seconds, without traditional payment infrastructure.

Traditional API monetization requires

With x402

Components of x402

The x402 ecosystem consists of three main components, which are:

Client Side:

This is the interface e.g frontend, that users interact with, which initiates a request to access a paid resource. It handles the payment requirements, prepare payment payload and resubmits the request with payment.

Clients do not need to manage accounts, credentials, or session tokens beyond their crypto wallet. All interactions are stateless and occur over standard HTTP requests.

Server Side:

The server is the resource provider enforcing payment for access to its services, such as API services, content providers, or any HTTP-accessible resource requiring monetization. It defines payment requirements, verifies payment payloads, settles transactions, and provides the resources.

Servers do not need to manage client identities or maintain session state. Verification and settlement are handled per request.

Facilitators:

The facilitator is an optional but recommended service that verifies and settles payment between clients and servers.

Architecture Overview

Key Components Explained:

Component

Role

SDK to Use

Who is x402 For?

API Developers — Monetize your APIs without managing subscriptions or API keys
AI Agents — Enable autonomous systems to pay for resources programmatically
Content Creators — Charge per article, image, or download

Real-Life Use Cases

AI Agent Economy — AI agents paying for web searches, API calls, or compute resources
Pay-Per-Article News — Read individual articles without monthly subscriptions
Blockchain Data Services — Pay-per-query for on-chain analytics

What You're Building

In this guide, you'll build a complete pay-per-request blockchain data API:

Backend: Express.js server with x402 payment middleware
Frontend: Vanilla JavaScript dApp with MetaMask integration
Data Source: GetBlock's Ethereum node API

Endpoints you'll create:

Endpoint

Price

Description

Prerequisites

Node.js 18+
MetaMask wallet
Base Sepolia USDC (from )

A. Project Setup

Step 1: Create Project Directories

Step 2: Initialize Server Package

Step 3: Install Dependencies

Dependency Overview:

Package

Purpose

Step 4: Configure package.json

Update server/package.json:

Folder Structure

Create the following project structure:

Backend: Express Server with x402

Step 1: Environment Configuration

Create server/.env:

Replace 0xYourWalletAddressHere with your actual MetaMask wallet address. This is where you'll receive USDC payments.

Step 2: Create the Server

Create server/server.js and add the following code:

Frontend: Vanilla JS dApp

Create client/index.html and add the following code:

Running the Application

Step 1: Start the Server

You should see:

Step 2: Access the Frontend

Open your browser and navigate to:

Your frontend should look like this:

Connect your wallet
Select any of the endpoints you want to access
Sign the request

The payment is then verified, scroll down to see the result

Troubleshooting

"Failed to create payment payload: Address undefined": This means the wallet client was not properly initialized. Make sure you're using getAddress() to normalize the address:

CORS Errors: This means the server not configured for x402 headers. Ensure CORS middleware includes x402 headers:

"Facilitator does not support scheme": This mean the facilitator is unreachable or doesn't support your network. To resolve this:

i. Check internet connection

ii. Try an alternative facilitator: https://facilitator.payai.network

iii. Verify you're using the correct network ID: eip155:84532

"Facilitator Connectivity Issues"

If the default facilitator is down, you can try:

Wallet Signing Problems

If MetaMask shows an error during signing:

Check network — Ensure you're on Base Sepolia (Chain ID 84532)
Check balance — Ensure you have enough USDC for the request

Debug Mode

Enable the debug log by clicking "Toggle Debug Log" at the bottom of the page. This shows:

Connection steps
Network switching
Signing requests
API responses

Resources

Conclusion

In this guide, you learnt what x402 is all about, including its use cases, components, architecture diagram etc. You also learnt how to set up the project and built a complete pay-per-request blockchain data API using x402 and GetBlock.

server/server.js

import express from "express";
import cors from "cors";
import path from "path";
import { fileURLToPath } from "url";
import { paymentMiddleware } from "@x402/express";
import { x402ResourceServer, HTTPFacilitatorClient } from "@x402/core/server";
import { registerExactEvmScheme } from "@x402/evm/exact/server";
import axios from "axios";
import "dotenv/config";

// ES Module directory resolution
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();

// =============================================================================
// CORS Configuration
// =============================================================================
// x402 uses custom headers for payment data, so we need to expose them
app.use(
  cors({
    origin: true,
    credentials: true,
    methods: ["GET", "POST", "OPTIONS"],
    allowedHeaders: [
      "Content-Type",
      "Authorization",
      "X-PAYMENT",
      "X-Payment",
      "x-payment",
    ],
    exposedHeaders: [
      "X-PAYMENT-RESPONSE",
      "X-Payment-Response",
      "x-payment-response",
      "X-PAYMENT-REQUIRED",
      "X-Payment-Required",
      "x-payment-required",
    ],
  })
);

app.use(express.json());

// =============================================================================
// Request Logging (for debugging)
// =============================================================================
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
  
  const paymentHeader = req.headers["x-payment"] || req.headers["X-PAYMENT"];
  if (paymentHeader) {
    console.log("  Payment header present (length:", paymentHeader.length, ")");
  }
  
  next();
});

// =============================================================================
// Configuration
// =============================================================================
const payTo = process.env.PAYMENT_WALLET_ADDRESS;
const GETBLOCK_API_KEY = process.env.GETBLOCK_API_KEY;
const GETBLOCK_URL = GETBLOCK_API_KEY
  ? `https://go.getblock.io/${GETBLOCK_API_KEY}`
  : null;

console.log("\n📋 Configuration:");
console.log(`   Payment wallet: ${payTo}`);
console.log(`   GetBlock API: ${GETBLOCK_API_KEY ? "Configured" : "Not configured (using mock data)"}`);

// Validate required config
if (!payTo) {
  console.error("❌ Missing PAYMENT_WALLET_ADDRESS in .env");
  process.exit(1);
}

// =============================================================================
// GetBlock API Helper
// =============================================================================
async function callGetBlock(method, params = []) {
  // If no API key, return mock data for demo purposes
  if (!GETBLOCK_URL) {
    console.log("  Using mock data (no GetBlock API key)");
    if (method === "eth_blockNumber") {
      const mockBlock = Math.floor(Date.now() / 1000);
      return { result: "0x" + mockBlock.toString(16) };
    }
    if (method === "eth_gasPrice") {
      return { result: "0x" + (20 * 1e9).toString(16) }; // 20 Gwei
    }
    return { result: null };
  }

  // Call GetBlock API
  try {
    const response = await axios.post(GETBLOCK_URL, {
      jsonrpc: "2.0",
      id: "getblock",
      method,
      params,
    });
    return response.data;
  } catch (error) {
    console.error("  GetBlock API error:", error.message);
    throw error;
  }
}

// =============================================================================
// x402 Setup
// =============================================================================

// Initialize the facilitator client
// The facilitator verifies payment signatures and settles transactions
const facilitatorUrl = "https://facilitator.payai.network";
console.log(`   Facilitator: ${facilitatorUrl}`);

const facilitatorClient = new HTTPFacilitatorClient({
  url: facilitatorUrl,
});

// Create the resource server and register the EVM payment scheme
const server = new x402ResourceServer(facilitatorClient);
registerExactEvmScheme(server);

// =============================================================================
// Payment Route Configuration
// =============================================================================
// Define which routes require payment and how much they cost
const paymentConfig = {
  "GET /api/eth/block/latest": {
    accepts: [
      {
        scheme: "exact",           // Payment scheme (exact amount)
        price: "$0.001",           // Price in USD
        network: "eip155:84532",   // Base Sepolia (CAIP-2 format)
        payTo,                     // Your wallet address
      },
    ],
    description: "Get latest Ethereum block number",
    mimeType: "application/json",
  },
  
  "GET /api/eth/gas": {
    accepts: [
      {
        scheme: "exact",
        price: "$0.001",
        network: "eip155:84532",
        payTo,
      },
    ],
    description: "Get current gas price",
    mimeType: "application/json",
  },
};

// Apply the payment middleware
// This intercepts requests to protected routes and verifies payment
app.use(paymentMiddleware(paymentConfig, server));

// =============================================================================
// Static Files & Routes
// =============================================================================

// Serve the frontend
app.use(express.static(__dirname));

app.get("/", (req, res) => {
  res.sendFile(path.join(__dirname, "../client/index.html"));
});

// Free endpoint: API information
app.get("/api", (req, res) => {
  res.json({
    message: "GetBlock x402 API",
    version: "1.0.0",
    network: "Base Sepolia (eip155:84532)",
    facilitator: facilitatorUrl,
    payTo,
    endpoints: [
      {
        path: "/api/eth/block/latest",
        price: "$0.001 USDC",
        description: "Get latest Ethereum block number",
      },
      {
        path: "/api/eth/gas",
        price: "$0.001 USDC",
        description: "Get current gas price",
      },
    ],
  });
});

// =============================================================================
// Protected Endpoints (require payment)
// =============================================================================

// Get latest block number
app.get("/api/eth/block/latest", async (req, res) => {
  console.log("  ✓ Payment verified - serving block data");
  try {
    const result = await callGetBlock("eth_blockNumber");
    res.json({
      blockNumber: result.result,
      decimal: parseInt(result.result, 16),
      timestamp: new Date().toISOString(),
      source: GETBLOCK_URL ? "getblock" : "mock",
    });
  } catch (error) {
    console.error("  Error fetching block number:", error.message);
    res.status(500).json({ error: error.message });
  }
});

// Get current gas price
app.get("/api/eth/gas", async (req, res) => {
  console.log("  ✓ Payment verified - serving gas data");
  try {
    const result = await callGetBlock("eth_gasPrice");
    const gasPriceWei = BigInt(result.result);
    res.json({
      gasPriceWei: result.result,
      gasPriceGwei: (Number(gasPriceWei) / 1e9).toFixed(2),
      timestamp: new Date().toISOString(),
      source: GETBLOCK_URL ? "getblock" : "mock",
    });
  } catch (error) {
    console.error("  Error fetching gas price:", error.message);
    res.status(500).json({ error: error.message });
  }
});

// =============================================================================
// Error Handling
// =============================================================================
app.use((err, req, res, next) => {
  console.error("Server error:", err);
  res.status(500).json({ error: err.message });
});

// =============================================================================
// Start Server
// =============================================================================
const PORT = process.env.PORT || 4021;
app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
  console.log("Protected endpoints:");
  Object.entries(paymentConfig).forEach(([route, config]) => {
    console.log(`   ${route} - ${config.accepts[0].price} USDC`);
  })
});

client/index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>GetBlock x402 dApp</title>
    <style>
      * {
        box-sizing: border-box;
        margin: 0;
        padding: 0;
      }
      body {
        font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", sans-serif;
        background: rgb(0, 0, 0);
        min-height: 100vh;
        color: #fff;
        padding: 2rem;
      }
      .container {
        max-width: 700px;
        margin: 0 auto;
      }
      header {
        text-align: center;
        margin-bottom: 2rem;
      }
      h1 {
        font-size: 2.2rem;
        margin-bottom: 0.5rem;
        background: linear-gradient(90deg, #00d4ff, #7b2cbf);
        -webkit-background-clip: text;
        -webkit-text-fill-color: transparent;
        background-clip: text;
      }
      .subtitle {
        color: #888;
        margin-bottom: 1.5rem;
      }
      .wallet-section {
        text-align: center;
        margin-bottom: 2rem;
      }
      #connectBtn {
        background: #7b2cbf;
        color: white;
        border: none;
        padding: 1rem 2rem;
        border-radius: 12px;
        font-size: 1.1rem;
        font-weight: 600;
        cursor: pointer;
        transition: all 0.3s ease;
      }
      #connectBtn:hover {
        opacity: 0.9;
        transform: translateY(-2px);
      }
      #walletInfo {
        background: rgba(0, 212, 255, 0.1);
        border: 1px solid rgba(0, 212, 255, 0.3);
        padding: 1rem;
        border-radius: 12px;
        display: none;
      }
      #walletInfo.connected {
        display: block;
      }
      .wallet-address {
        font-family: monospace;
        color: #00d4ff;
      }
      .endpoints {
        margin-top: 2rem;
      }
      .endpoints h2 {
        font-size: 1.2rem;
        color: #888;
        margin-bottom: 1rem;
      }
      .endpoint-card {
        display: flex;
        justify-content: space-between;
        align-items: center;
        padding: 1.25rem;
        background: rgba(255, 255, 255, 0.05);
        border-radius: 12px;
        margin-bottom: 0.75rem;
        border: 1px solid rgba(255, 255, 255, 0.1);
        transition: all 0.3s ease;
      }
      .endpoint-card:hover {
        background: rgba(255, 255, 255, 0.08);
        border-color: rgba(0, 212, 255, 0.3);
      }
      .endpoint-name {
        font-weight: 600;
        margin-bottom: 0.25rem;
      }
      .endpoint-price {
        color: #00d4ff;
        font-size: 0.9rem;
      }
      .pay-btn {
        background: #7b2cbf;
        color: white;
        border: none;
        padding: 0.6rem 1.2rem;
        border-radius: 8px;
        font-weight: 600;
        cursor: pointer;
        transition: all 0.3s ease;
      }
      .pay-btn:hover {
        opacity: 0.9;
      }
      .pay-btn:disabled {
        opacity: 0.5;
        cursor: not-allowed;
      }
      #status {
        margin-top: 1.5rem;
        padding: 1rem;
        border-radius: 12px;
        display: none;
      }
      #status.error {
        display: block;
        background: rgba(255, 0, 0, 0.1);
        border: 1px solid rgba(255, 0, 0, 0.3);
        color: #ff6b6b;
      }
      #status.loading {
        display: block;
        background: rgba(255, 255, 0, 0.1);
        border: 1px solid rgba(255, 255, 0, 0.3);
        color: #ffd93d;
      }
      #status.success {
        display: block;
        background: rgba(0, 255, 0, 0.1);
        border: 1px solid rgba(0, 255, 0, 0.3);
        color: #00ff88;
      }
      #result {
        margin-top: 1.5rem;
        display: none;
      }
      #result.show {
        display: block;
      }
      #result h3 {
        color: #00ff88;
        margin-bottom: 0.75rem;
      }
      #result pre {
        background: rgba(0, 0, 0, 0.4);
        padding: 1rem;
        border-radius: 8px;
        overflow-x: auto;
        font-size: 0.9rem;
      }
      footer {
        text-align: center;
        margin-top: 3rem;
        color: #666;
        font-size: 0.85rem;
      }
      .network-badge {
        display: inline-block;
        background: rgba(123, 44, 191, 0.2);
        color: #b57edc;
        padding: 0.25rem 0.75rem;
        border-radius: 20px;
        font-size: 0.8rem;
        margin-top: 0.5rem;
      }
      .info-box {
        background: rgba(255, 255, 255, 0.05);
        border: 1px solid rgba(255, 255, 255, 0.1);
        border-radius: 12px;
        padding: 1rem;
        margin-bottom: 1.5rem;
        font-size: 0.9rem;
        color: #aaa;
      }
      .info-box a {
        color: #00d4ff;
        text-decoration: none;
      }
      .info-box a:hover {
        text-decoration: underline;
      }
      .debug-log {
        background: rgba(0, 0, 0, 0.3);
        padding: 0.5rem;
        margin-top: 1rem;
        border-radius: 8px;
        font-family: monospace;
        font-size: 0.75rem;
        max-height: 200px;
        overflow-y: auto;
        display: none;
      }
      .debug-log.show {
        display: block;
      }
    </style>
  </head>
  <body>
    <div class="container">
      <header>
        <h1>GetBlock x402 dApp</h1>
        <p class="subtitle">Pay-per-request blockchain data powered by x402</p>
      </header>

      <div class="info-box">
        <strong>Requirements:</strong> MetaMask wallet with USDC on Base Sepolia testnet.<br />
        Get test USDC from <a href="https://faucet.circle.com/" target="_blank">Circle Faucet</a>
      </div>

      <div class="wallet-section">
        <button id="connectBtn">Connect Wallet</button>
        <div id="walletInfo">
          <p>Connected: <span class="wallet-address" id="walletAddress"></span></p>
          <p style="margin-top: 0.5rem; font-size: 0.85rem; color: #888">
            USDC Balance: <span id="usdcBalance">Loading...</span>
          </p>
          <span class="network-badge">Base Sepolia Testnet</span>
        </div>
      </div>

      <div class="endpoints" id="endpoints" style="display: none">
        <h2>Available Endpoints</h2>
        <div class="endpoint-card">
          <div>
            <div class="endpoint-name">Latest Block Number</div>
            <div class="endpoint-price">$0.001 USDC</div>
          </div>
          <button class="pay-btn" data-endpoint="/api/eth/block/latest">Pay & Fetch</button>
        </div>
        <div class="endpoint-card">
          <div>
            <div class="endpoint-name">Current Gas Price</div>
            <div class="endpoint-price">$0.001 USDC</div>
          </div>
          <button class="pay-btn" data-endpoint="/api/eth/gas">Pay & Fetch</button>
        </div>
      </div>

      <div id="status"></div>
      <div id="result">
        <h3>✓ Result</h3>
        <pre id="resultData"></pre>
      </div>

      <footer>
        <p>Network: Base Sepolia | Powered by GetBlock & x402</p>
        <a href="#" id="toggleDebug" style="color: #666; font-size: 0.75rem">Toggle Debug Log</a>
        <div class="debug-log" id="debugLog"></div>
      </footer>
    </div>

    <!-- Load dependencies from CDN -->
    <script type="module">
      // =======================================================================
      // Import Dependencies
      // =======================================================================
      import {
        createWalletClient,
        custom,
        getAddress,
      } from "https://esm.sh/[email protected]";
      import { baseSepolia } from "https://esm.sh/[email protected]/chains";
      import {
        x402Client,
        wrapFetchWithPayment,
      } from "https://esm.sh/@x402/fetch";
      import { registerExactEvmScheme } from "https://esm.sh/@x402/evm/exact/client";

      // =======================================================================
      // Configuration
      // =======================================================================
      const API_URL = "http://localhost:4021";
      const BASE_SEPOLIA_CHAIN_ID = "0x14a34"; // 84532 in hex
      const USDC_ADDRESS = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // Base Sepolia USDC

      // =======================================================================
      // State
      // =======================================================================
      let fetchWithPayment = null;
      let userAddress = null;

      // =======================================================================
      // DOM Elements
      // =======================================================================
      const connectBtn = document.getElementById("connectBtn");
      const walletInfo = document.getElementById("walletInfo");
      const walletAddressEl = document.getElementById("walletAddress");
      const usdcBalanceEl = document.getElementById("usdcBalance");
      const endpointsSection = document.getElementById("endpoints");
      const statusEl = document.getElementById("status");
      const resultEl = document.getElementById("result");
      const resultData = document.getElementById("resultData");
      const debugLog = document.getElementById("debugLog");
      const toggleDebug = document.getElementById("toggleDebug");

      // =======================================================================
      // Debug Logging
      // =======================================================================
      function log(msg, type = "info") {
        const time = new Date().toLocaleTimeString();
        const color =
          type === "error" ? "#ff6b6b" : type === "success" ? "#00ff88" : "#aaa";
        debugLog.innerHTML += `<div style="color:${color}">[${time}] ${msg}</div>`;
        debugLog.scrollTop = debugLog.scrollHeight;
        console.log(`[${type}]`, msg);
      }

      toggleDebug.addEventListener("click", (e) => {
        e.preventDefault();
        debugLog.classList.toggle("show");
      });

      function showStatus(message, type) {
        statusEl.textContent = message;
        statusEl.className = type || "";
      }

      // =======================================================================
      // USDC Balance Helper
      // =======================================================================
      async function getUsdcBalance(address) {
        try {
          // Call balanceOf(address) on USDC contract
          const data = "0x70a08231" + address.slice(2).padStart(64, "0");
          const result = await window.ethereum.request({
            method: "eth_call",
            params: [{ to: USDC_ADDRESS, data }, "latest"],
          });
          const balance = parseInt(result, 16) / 1e6; // USDC has 6 decimals
          return balance.toFixed(6);
        } catch (e) {
          log("Error getting USDC balance: " + e.message, "error");
          return "0.000000";
        }
      }

      // =======================================================================
      // Create x402-Compatible Signer
      // =======================================================================
      /**
       * Creates a signer object that x402 can use to sign payment authorizations.
       * This wraps MetaMask's signing capabilities in the interface x402 expects.
       */
      function createMetaMaskSigner(address, walletClient) {
        return {
          address: address,

          async signTypedData(typedData) {
            log("Signing payment authorization...");
            log("Domain: " + JSON.stringify(typedData.domain));

            try {
              // Use viem's signTypedData which handles EIP-712 formatting
              const signature = await walletClient.signTypedData({
                account: address,
                domain: typedData.domain,
                types: typedData.types,
                primaryType: typedData.primaryType,
                message: typedData.message,
              });

              log("Signature obtained: " + signature.substring(0, 20) + "...", "success");
              return signature;
            } catch (error) {
              log("Signing error: " + error.message, "error");
              throw error;
            }
          },
        };
      }

      // =======================================================================
      // Connect Wallet Handler
      // =======================================================================
      connectBtn.addEventListener("click", async () => {
        try {
          if (!window.ethereum) {
            showStatus("Please install MetaMask!", "error");
            return;
          }

          showStatus("Connecting wallet...", "loading");
          log("Requesting wallet connection...");

          // Request account access
          const accounts = await window.ethereum.request({
            method: "eth_requestAccounts",
          });
          userAddress = getAddress(accounts[0]); // Normalize address checksum
          log("Connected to: " + userAddress, "success");

          // Switch to Base Sepolia network
          log("Checking network...");
          try {
            await window.ethereum.request({
              method: "wallet_switchEthereumChain",
              params: [{ chainId: BASE_SEPOLIA_CHAIN_ID }],
            });
            log("On Base Sepolia", "success");
          } catch (switchError) {
            // Network not added - add it
            if (switchError.code === 4902) {
              log("Adding Base Sepolia network...");
              await window.ethereum.request({
                method: "wallet_addEthereumChain",
                params: [
                  {
                    chainId: BASE_SEPOLIA_CHAIN_ID,
                    chainName: "Base Sepolia",
                    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
                    rpcUrls: ["https://sepolia.base.org"],
                    blockExplorerUrls: ["https://sepolia.basescan.org"],
                  },
                ],
              });
            } else {
              throw switchError;
            }
          }

          // Create viem wallet client
          log("Creating wallet client...");
          const walletClient = createWalletClient({
            account: userAddress,
            chain: baseSepolia,
            transport: custom(window.ethereum),
          });

          // Create x402-compatible signer
          log("Creating x402 signer...");
          const signer = createMetaMaskSigner(userAddress, walletClient);

          // Initialize x402 client with EVM scheme
          log("Initializing x402 client...");
          const x402client = new x402Client();
          registerExactEvmScheme(x402client, { signer });

          // Wrap fetch with automatic payment handling
          fetchWithPayment = wrapFetchWithPayment(fetch, x402client);
          log("x402 client ready!", "success");

          // Update UI
          walletAddressEl.textContent = `${userAddress.slice(0, 6)}...${userAddress.slice(-4)}`;

          const balance = await getUsdcBalance(userAddress);
          usdcBalanceEl.textContent = balance + " USDC";
          log("USDC Balance: " + balance);

          walletInfo.classList.add("connected");
          connectBtn.style.display = "none";
          endpointsSection.style.display = "block";
          showStatus("", "");
        } catch (error) {
          log("Connection error: " + error.message, "error");
          showStatus("Connection failed: " + error.message, "error");
        }
      });

      // =======================================================================
      // Endpoint Button Click Handlers
      // =======================================================================
      document.querySelectorAll(".pay-btn").forEach((btn) => {
        btn.addEventListener("click", async () => {
          if (!fetchWithPayment) {
            showStatus("Please connect wallet first", "error");
            return;
          }

          const endpoint = btn.dataset.endpoint;
          const fullUrl = API_URL + endpoint;

          // Disable buttons during request
          document.querySelectorAll(".pay-btn").forEach((b) => (b.disabled = true));
          btn.textContent = "Processing...";
          showStatus("Making request...", "loading");
          resultEl.classList.remove("show");

          try {
            log("Request: GET " + fullUrl);

            // Make the paid request - x402 handles payment automatically
            const response = await fetchWithPayment(fullUrl, { method: "GET" });

            log("Response status: " + response.status);

            if (response.status === 402) {
              const text = await response.text();
              log("402 response: " + text.substring(0, 200), "error");

              try {
                const data = JSON.parse(text);
                if (data.accepts) {
                  log("Payment requirements received", "error");
                  throw new Error("Payment failed - check USDC balance and try again");
                }
                throw new Error(data.error || "Payment required");
              } catch (e) {
                if (e.message.includes("Payment") || e.message.includes("USDC")) throw e;
                throw new Error("Payment required");
              }
            }

            if (!response.ok) {
              const text = await response.text();
              log("Error: " + text, "error");
              throw new Error(`Failed (${response.status}): ${text}`);
            }

            // Success! Display the data
            const data = await response.json();
            log("Success!", "success");
            resultData.textContent = JSON.stringify(data, null, 2);
            resultEl.classList.add("show");
            showStatus("✓ Payment successful!", "success");

            // Refresh USDC balance
            const newBalance = await getUsdcBalance(userAddress);
            usdcBalanceEl.textContent = newBalance + " USDC";
          } catch (error) {
            log("Error: " + error.message, "error");
            showStatus("Error: " + error.message, "error");
          } finally {
            // Re-enable buttons
            document.querySelectorAll(".pay-btn").forEach((b) => {
              b.disabled = false;
              b.textContent = "Pay & Fetch";
            });
          }
        });
      });

      // =======================================================================
      // Handle Wallet Events
      // =======================================================================
      if (window.ethereum) {
        window.ethereum.on("accountsChanged", () => location.reload());
        window.ethereum.on("chainChanged", () => location.reload());
      }

      // =======================================================================
      // Initialize
      // =======================================================================
      log('Ready. Click "Connect Wallet" to start.');
      log("Toggle this debug log with the link below.");
    </script>
  </body>
</html>

GitHub sync

Welcome

hashtagCore GetBlock features

hashtagDiscover GetBlock

hashtagPopular chains

hashtagGetBlock Product Demo

GETTING STARTED

How to set up an account

hashtagAccess the dashboard

hashtagCheck your User ID

Access token management

hashtagMaking an authenticated request

Plans and limits

Choosing your plan

hashtagShared nodes

Top up CUs and boost limits

hashtagAdd Compute Units: Paid plan users

Payment methods

hashtagFiat payments

hashtagUpdating your payment details

hashtagCrypto payments

Endpoint setup

Testing RPC connection

Using cURL for testing

hashtagFetch the current block number

hashtagGet the chain ID

hashtagCheck account balance by address

Postman Collection

Errors and troubleshooting

hashtagConnection issues

hashtagJSON-RPC errors

Monitoring and analytics

hashtagDashboard

BSC Advanced Tooling

Sending Transactions to Private Mempool (Priority Fee)

hashtagChoosing a Method

hashtagDifferent Between Bundles and Transactions

hashtagNext Steps

Solana Advanced Data Tools

ADD-ONS

GUIDES

Using Web3 libraries

Web3.js integration

hashtagInstall Web3.js

hashtagSet up your connection to GetBlock

How to generate accounts and send transactions

hashtagCreating accounts

Ethers.js integration

hashtagInstall Ethers.js

hashtagSet GetBlock as a provider

TronWeb integration

hashtagMethod response:

API REFERENCE

db_getHex {disallowed} - Arbitrum

hashtagParameters

db_getString {disallowed} - Arbitrum

hashtagParameters

db_putHex {disallowed} - Arbitrum

hashtagParameters

db_putString {disallowed} - Arbitrum

hashtagParameters

eth_coinbase {disallowed} - Arbitrum

hashtagParameters

hashtag

Welcome

hashtagCore GetBlock features

hashtagDiscover GetBlock

hashtagPopular chains

hashtagGetBlock Product Demo

Testing RPC connection

Using Web3 libraries

Endpoint setup

Plans and limits

Access token management

hashtagMaking an authenticated request

Top up CUs and boost limits

hashtagAdd Compute Units: Paid plan users

Monitoring and analytics

hashtagDashboard

Postman Collection

Core GetBlock features

Discover GetBlock

Popular chains

GetBlock Product Demo

Access the dashboard

Check your User ID

Making an authenticated request

Shared nodes

Add Compute Units: Paid plan users

Fiat payments

Updating your payment details

Crypto payments

Fetch the current block number

Get the chain ID

Check account balance by address

Connection issues

JSON-RPC errors

Dashboard

Choosing a Method

Different Between Bundles and Transactions

Next Steps

Install Web3.js

Set up your connection to GetBlock

Creating accounts

Install Ethers.js

Set GetBlock as a provider

Method response:

Parameters

Parameters

Parameters

Parameters

Parameters

Core GetBlock features

Discover GetBlock

Popular chains

GetBlock Product Demo

Making an authenticated request

Add Compute Units: Paid plan users

Dashboard

Parameters

Parameters

Parameters

Parameters

Parameters

Request

Response

Request

Response

Response

Request

Response

Request

Response

Access Token security

Increase CU limits: Free plan users

Boost CU, RPS, and Access Token limits

Detailed statistics

Notifications and email communication

Fetch the current block number

Get the chain ID

Check account balance by address

Choosing a Method

Different Between Bundles and Transactions

Next Steps

Fiat payments

Updating your payment details

Crypto payments

Method response:

Access the dashboard

Check your User ID

Install Ethers.js

Set GetBlock as a provider

Connection issues

JSON-RPC errors

Install Web3.js

Set up your connection to GetBlock

Shared nodes

Creating accounts

Sending transactions

Dedicated nodes