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.

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.

Every endpoint you create is assigned a unique access token:

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

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

Making an authenticated request

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

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

Response:

Access Token security

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

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

1. Go to your GetBlock Dashboard.

2. Locate the endpoint associated with the token.

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

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

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

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.

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

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

In the setup window:

1. Review and confirm your selected protocol and network.

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

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

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

Add Compute Units: Paid plan users

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

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

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

3. Confirm and finalize your purchase.

Your account balance will be updated immediately upon successful payment.

Increase CU limits: Free plan users

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

Boost CU, RPS, and Access Token limits

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

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

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

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

Import the collection into your Postman workspace: .

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

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

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

Parameters

database - string

Database name

key - string

key name

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

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

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

GetBlock 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), eth_getStorageAt(contract, slot, blockNumber), eth_getCode(address, blockNumber), etc.

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

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

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

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

Archive mode availability & coverage

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

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

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

How to enable the Archive mode

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

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

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

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

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

CU billing for Shared Archive endpoints

Archive endpoints usage remains subject to your plan’s .

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

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

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

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

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

Example:

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

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

Best practices

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

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

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

💬 Need help with archive blockchain data?

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

How to make HTTP requests with curl using JSON config file

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

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

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

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

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

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

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

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

• Npm: npm install web3

• Yarn: yarn add web3

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

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

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

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

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

How to use the JS config with Hardhat

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

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

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

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

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

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 https://getblock.io/pricing/.

Shared nodes

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

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

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

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

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

Dedicated nodes

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

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

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

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

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

Enterprise solutions

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

What’s included:

• 99.9% uptime guarantee

• Customizable node configurations and integrations

• Performance optimization via load balancers

• Advanced analytics and alert systems

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

Dedicated Nodes are fully private blockchain nodes deployed and managed for your team. With two distinct performance presets, you can balance throughput, SLA, and budget to fit your workload.

Available tiers:

1. High Performance Tier: Designed to provide maximum available resources, throughput, and reliability. It is intended for applications where performance and availability are critical. The focus is on delivering the highest service levels and supporting the most demanding production workloads.

2. Standard Performance Tier: Designed to offer enterprise-grade performance sufficient for the majority of professional and business use cases, but at a more cost-efficient level. It targets demanding business applications and sustained usage, but without the additional (and sometimes excessive) headroom reserved for High Performance tier.

By providing these options, GetBlock helps you to deploy Dedicated Nodes that are tailored to your application’s technical, operational, and budget requirements.

Dedicated Node tiers overview

When deploying a Dedicated Node, you can choose between High and Standard setups to align with your application’s resource needs and expected workload.

• Select High if your workload is latency-sensitive, demands very high concurrent throughput, or is critical to business continuity.

• Select Standard for typical production apps, where workload is within supported performance bounds.

Configuring tiers is available for all supported protocols unless there are specific infrastructure limitations for a given network. In this case, a chain will only support a single tier.

High vs Standard tier comparison table

Dedicated Node pricing

Dedicated Nodes are billed at a set monthly rate determined by configured settings:

1. Performance tier: Total cost scales with the performance tier selected – High tier is priced at a premium relative to the Standard tier.

2. Blockchain network: Each protocol has different hardware requirements, which impact both High and Standard tier pricing.

3. Node mode: Full or Archive.

4. Client parameters.

Refer to your Dashboard for up-to-date pricing details and protocol-specific options.

Steps to configure dedicated node tiers

To select a tier during node setup, open the Dedicated Node dashboard:

1. Select protocol, network, deployment region, node mode, and a preferred client.

2. As a final step, choose the Performance Tier (High or Standard) and required API interfaces.

1. Review updated performance and pricing details.

Your dedicated node will be ready for use upon activation. To switch between tiers after deploying, reach out to support.

Need a more customized setup?

For advanced workloads or unique requirements, our engineering team can help craft a custom private node solution beyond the High/Standard presets. for tailored deployments.

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

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

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

Full vs Archive mode

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

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

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

Viewing and managing endpoints

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

Connection issues

JSON-RPC errors

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

Install Ethers.js

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

• npm

• yarn

Set GetBlock as a provider

For further details and advanced usage, explore the .

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

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

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

Creating accounts

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

const Web3 = require('web3');

//Set up the provider (replace ACCESS-TOKEN with your actual token)
const web3 = new Web3('https://go.getblock.io/<ACCESS-TOKEN>/');

Next, we can create an account on the testnet:

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

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

Sending transactions

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

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

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

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

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

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

• Npm:

npm install tronweb

• Yarn:

yarn add tronweb

In your javascript file, define TronWeb:

When you instantiate TronWeb you can define:

• fullNode

• solidityNode

• eventServer

• privateKey

you can also set a

• fullHost

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

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

After this you can call any TronWeb method:

All API references can be found in the project documentation at

Method response:

Parameters

database - string

database name

key - string

key name

string - string

string to store.

Request

Response

Parameters

database - string

database name

key - string

key name

Request

Response

Parameters

-

Request

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

Response

Parameters

database - string

database name

key - string

key name

data - data

data to store.

Request

Response

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

Dashboard

The Dashboard provides a quick snapshot of key metrics:

• Your current plan details

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:

Parameters

-

Request

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

Key benefits:

• Organized collaboration: Work together on company resources.

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

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

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

Creating a team account on GetBlock

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

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

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

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

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

Adding teammates

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

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

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

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

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

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

Managing roles & permissions

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

1. Go to My Team in Account Settings.

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

3. Select "Edit access level".

4. Assign permissions:

Roles-based permissions

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

Revoking team access

To remove a user from your team account:

1. Navigate to Team in the Account Settings.

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

3. Select "Remove" from the dropdown menu.

How to join a team account

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

Switching between personal & team accounts

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

• Click the account icon in the left panel.

• A dropdown will show all teams & personal accounts.

• Switch between them as needed.

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

Best practices for team security

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

• Grant admin privileges only to trusted team members.

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

• Never share login credentials—use team accounts instead.

Need help?

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

Before you start:

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

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

Fetch the current block number

Run the following command to retrieve the latest block number:

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

Get the chain ID

Identify the blockchain network with the eth_chainId method:

Response example:

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

Check account balance by address

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

Example response:

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

TradeFirst is an infrastructure that combines other GetBlock and external infrastructures, specifically designed for high-frequency traders (HFT) on Solana. It combines multiple performance optimizations:

• fast data streaming (StreamFirst)

• intelligent transaction routing (LandFirst)

into a single, integrated solution for professional trading operations.

Interested in building on Solana with TradeFirst? Reach us for more information.

Core Value Proposition

TradeFirst provides two-sided latency optimization for Solana trading:

1. Signal Detection Side: Faster awareness of on-chain events via StreamFirst (data streaming).

2. Execution Side: Faster transaction delivery and inclusion via Blazar, SubSlot, and LandFirst routing

By optimizing both sides, TradeFirst enables traders to see opportunities earlier and execute trades faster than competitors using standard infrastructure.

Core Technology Stack

1. StreamFirst (Data Streaming)

   1. Accelerated Yellowstone gRPC implementation

   2. Optimized shred-stream network access

   3. Fastest on-chain data delivery for signal detection

Technical Architecture

How TradeFirst Works

Complete Trading Cycle:

1. Signal Detection: StreamFirst delivers on-chain updates 17ms faster than standard methods

2. Strategy Execution: Your trading logic analyzes data and generates orders

3. Transaction Submission: Blazar optimizes transaction structure and routing

4. Timing Control: SubSlot precisely times submission within the slot window

Use cases

This is highly recommended for High-frequency trading (HFT) traders, which is specifically designed for:

1. High-Frequency Trading Firms

These are professional trading teams running large volumes of rapid-fire transactions on Solana, including cross-DEX arbitrage, statistical arbitrage across correlated token pairs, tight-spread market making, and fast liquidity rebalancing. For them, execution speed and reliability directly impact profitability, making this solution an essential part of their trading infrastructure.

2. MEV Searchers

MEV searchers rely on precise timing and high-priority execution for strategies like sandwich attacks, liquidation sniping, protocol arbitrage, or fast NFT flips. Since these opportunities exist for only seconds—and often compete with other searchers—having stronger execution reliability gives them a significant edge.

3. Algorithmic Trading Operations

Algorithmic trading systems continuously react to on-chain data, whether they're following momentum signals, trading based on oracle movements, optimizing yield across protocols, or executing automated rebalancing strategies. These systems need a consistent, low-latency execution layer to ensure their models perform as expected without disruptions.

4. Proprietary Trading Desks

Small teams and professional traders running their own capital depend on solid infrastructure without wanting to build it in-house. They benefit from flexible setups that support diverse strategies, predictable pricing so they know their cost structure, and reliable support for performance tuning or issue resolution.

5. Institutional Crypto Traders

Institutions executing high-volume Solana strategies require enterprise-level stability, compliance-friendly monitoring, volume-based pricing, and service-level guarantees. This solution gives them the dependable infrastructure and dedicated support needed to operate at scale while maintaining regulatory and operational standards.

For consultation on optimal deployment architecture for your specific use case, contact

Parameters

-

Request

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

Response

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

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

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

Tracking subscription status

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

Solana Indexed Archive is a software development kit(SDK) that provides an indexed data layer, enabling instant access to the complete Solana blockchain history and real-time data through a single, high-performance API. Built on SQD Network infrastructure, it eliminates the need to work with raw Solana data, run archive nodes, or maintain complex indexing logic.

Interested in building on Solana with Indexed Archive? for more information.

The Indexed Archive Solution

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

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

Before you start

Set up your wallet

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

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

Get a custom RPC URL

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

Add GetBlock RPC to an existing network

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

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

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

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

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

3. Name the new RPC URL for easier identification.

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

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

Add a new network to MetaMask

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

1. Click on the current network name.

2. Select 'Add a custom network'.

1. Fill in the required fields:

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

LandFirst is GetBlock's intelligent transaction-routing technology for processing faster transactions on Solana. It works by routing your transactions through multiple optimized delivery paths, including GetBlock’s Stake-Weighted Quality of Service (SWQoS) connections and the Jito auction mechanism.

Interested in building on Solana with LandFirst? Reach us for more information.

Core Technology Stack

LandFirst automatically routes transactions through three complementary delivery mechanisms:

1. GetBlock's Own SWQoS Connections

   1. Direct partnerships with high-stakes Solana validators

   2. Guaranteed priority capacity through stake-weighted allocation

   3. GetBlock-operated infrastructure with validator peering

2. Leased SWQoS Connections

   1. Higher priority than unstaked RPC traffic, ensuring transactions cut ahead during congestion

   2. Reserve priority bandwidth specifically for LandFirst traffic

3. Jito Block Engine Integration

   1. MEV-aware auction mechanism for guaranteed inclusion

   2. Bundle support for atomic multi-transaction operations

   3. Priority placement through competitive tipping

By combining all three paths, LandFirst provides the highest probability of fast transaction inclusion on Solana.

Technical Architecture

How It Works

LandFirst maximizes transaction inclusion by combining SWQoS priority routing, low-latency leader targeting, and parallel Jito submission. When a user sends a transaction, LandFirst checks the current leader schedule and picks the fastest path through our and our partners’ staked SWQoS validators, using private, low-hop connections to deliver the transaction directly to the upcoming leader with priority TPU capacity. At the same time, the transaction is also sent to Jito, where it enters the tip auction for guaranteed execution if the bundle wins. Whichever path lands first becomes the confirmed transaction, ensuring the highest possible probability of fast, next-block inclusion even under heavy network congestion.

Routing Intelligence:

LandFirst analyzes each transaction and selects the optimal delivery path based on:

• Leader Schedule: Which validator is currently/soon producing blocks

• Network Conditions: Current congestion and validator responsiveness

• Transaction Priority: Priority fee amount and urgency

• Geographic Location: network topology that defines the lowest-path latency to the current leader.

Use Cases

1. HFT & Arbitrage

Fast, reliable execution for high-frequency trading, arbitrage, market-making, and position rebalancing — especially when every millisecond counts.

1. MEV & Keeper / Liquidation Bots

Ensures deterministic transaction landing for backruns, front-runs, liquidation races, and other MEV or keeper-bot strategies.

1. NFT Sniping & High-Demand Mints

Gives an edge for time-sensitive NFT events such as limited-supply mints, snipes, and competitive auctions.

1. Critical Time-Sensitive Transactions

For urgent or large-value moves — e.g. multi-sig operations, time-bound transfers, or high-stakes governance — where failure or delay is too costly.

Different Between Multi-Path Routing Advantage vs. Standard RPC Transaction Submission

Standard RPC nodes submit transactions via single, unstaked TPU connections. During congestion, these transactions are deprioritized or dropped entirely.

Available to Everyone

LandFirst is available on:

✅ Shared Node Plans - All shared RPC users benefit automatically ✅ Dedicated Node Plans - Enhanced monitoring and configuration available ✅ No Additional Fee - Included in standard RPC access (tips are optional)

For consultation on optimal deployment architecture for your specific use case, contact

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.

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

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

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

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

4. Click Get, and the endpoint is ready.

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

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

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.

Overview

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

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

Key Features

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

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

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

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

Supported Data Streams

Yellowstone gRPC supports streaming the full range of Solana events:

Use Cases

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

• High-frequency trading and MEV bots

• On-chain indexers and data archives

• Real-time analytics dashboards

• DEX monitors and price feeds

Getting Started

Prerequisites

To use Yellowstone gRPC on GetBlock:

• A GetBlock account (sign up at )

• A subscription

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

Quick Example

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

Additional Resources

Need Help?

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

• Add-on activation and endpoint setup

• Integration guidance and troubleshooting

• Performance optimization

• Custom solutions for enterprise needs

Contact us through the or visit our .

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

What is Yellowstone gRPC?

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

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

How Yellowstone gRPC Geyser works

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

Supported data streams & subscriptions

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

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

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

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

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

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

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

• The Slot;

• Block height;

• Latest blockhash;

• Valid blockhash.

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

Yellowstone gRPC API features

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

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

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

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

Solana Geyser gRPC plugin use cases

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

gRPC API ideal use cases include:

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

• On-chain indexers & archives;

• Live analytics;

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

Why use Yellowstone gRPC API?

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

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

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

Overview of Aptos Network Methods

Aptos is a Layer 1 blockchain built with the Move programming language, designed to deliver a fast, secure, scalable, and upgradeable ecosystem. With its modular architecture, Aptos enables frequent upgrades, rapid adoption of new technologies, and strong support for emerging use cases. The Aptos API provides developers with the ability to interact with the blockchain seamlessly and possibly. You can do the following with the Aptos API:

1. Query real-time blockchain data

2. Manage and monitor accounts and balances

3. Interact with smart contracts

4. Submit and track transactions

5. Monitor network activity in real-time

Each method will provide you with the following:

1. Clear description of functionality and use cases

2. Required input parameters

3. Sample requests and responses

4. Supported network

Note: This API is compatible only with Aptos Mainnet.

Quickstart

In this section, you will learn how to make your first call with either:

• Axios

• Python

Quickstart with Axios

Before you begin, you must have already installed npm or yarn on your local machine. If not, check out or .

1. Set up your project using this command:

   For npm:

Or yarn:

This creates a project directory named aptos-api-quickstart and initialises a Node.js project within it.

1. Install Axios using this command: Using npm:

   Using yarn:

2. Create a new file and name it index.js. This is where you will make your first call.

3. Set ES module "type": "module" in your package.json.

Quickstart with Python and Requests

Before you begin, you must have installed Python and Pip on your local machine.

1. Set up your project using this command:

2. Set up a virtual environment to isolate dependencies:

3. Install the requests library:

4. Create a new file called and insert the following code:

   Replace

Endpoint Grouping

1. Blockchain Information

   • /v1

2. Account-Related

   • /v1/accounts/{account_hash}

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

Supported Network

• Mainnet

Parameters

• None

Request

URL (endpoint)

Example (cURL)

Response

Response Definition

Use Case

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

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

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

Code Example (Axios)

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

Error Handling

When using this endpoint, you may encounter:

• 404 → Incorrect or incomplete access token.

• 500 → Network issues.

How to fix:

• Use a stable and strong network connection.

• Check or re-copy your access token.

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

Integration

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

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

Supported Networks

• Mainnet

Parameters

Request Example

URL

Example

Response

Response Definition

Use Cases

This method can be used for:

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

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

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

Code Examples

Python (requests)

Node.js (Axios)

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

Error Handling

You may encounter responses like:

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

• 403 → Access token is missing.

Integration with Web3

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

• Fetch sequence numbers for transaction signing.

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

• Support wallet and dApp account management.

• Enable reliable transaction pipelines.

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

Supported Network

• Mainnet

Parameter

None

Request

Base URL

Example(cURL)*

Response Example

Response parameter definition

Use Cases

This method can be used for:

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

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

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

• Cost optimisation for batch transactions.

Code example

Node(axios)

Python(Request)

Error handling

Integration with Web3

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

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

• Improve transaction confirmation rates by suggesting optimal gas.

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

• Avoid failed transactions due to underpriced gas.

StreamFirst is GetBlock's infrastructure solution for delivering faster (ultra-low latency) on-chain state updates from the Solana blockchain.

By combining software-level acceleration with network-level optimization, StreamFirst enables developers to receive blockchain data faster than traditional RPC methods. This reduces the consistent polling updates, which either lead to timeouts or rate-limiting issues.

Interested in building on Solana with StreamFirst? for more information.

Core Stack

StreamFirst consists of two core optimization layers: