We’re introducing the Tatum Liquid Staking API, enabling developers to retrieve liquid staking balances and supported staking pools across major staking ecosystems (Solana, Ethereum).

Liquid Staking APIs

📘

Get Liquid Staking Current Assets

GET /v4/data/staking/liquid/current-assets
Retrieve all liquid staking tokens held by a wallet address across supported liquid staking protocols.
Explore Docs →

📚

Get Liquid Staking Pools

GET /v4/data/staking/liquid/pools
Explore Docs →
Retrieve all supported liquid staking pools and tokens for a blockchain, including major protocols like Lido, Rocket Pool, Marinade, and Jito.

With the Liquid Staking APIs, developers can:

• Detect liquid staking token balances held by wallets
• Discover supported liquid staking protocols and pools
• Build staking dashboards and portfolio trackers
• Power wallets and DeFi analytics platforms

These APIs simplify building applications that surface liquid staking positions across Ethereum and Solana ecosystems. Read more about this feature on Tatum website - Staking APIs.

We’ve expanded the Tatum Staking API to support Ethereum, enabling you to retrieve staking data directly from Ethereum wallets and validators.

Try Staking API in Dashboard

Explore staking data directly in the Tatum Dashboard.

Search any wallet address to view active stakes, validator details, and rewards in one place.

Ethereum Staking API Support

These endpoints are now available for Ethereum, allowing you to track validator activity, rewards, and staking transactions.

📘

Get Current Staked Assets

GET /v4/data/staking/native/current-assets
Returns all current staked assets for a given Ethereum address, including active stake details.
Explore Docs →

📚

Get Current Staked Assets by Validator

GET /v4/data/staking/native/current-assets-by-validator
Explore Docs →
Returns staked assets grouped by validator, including delegated amounts and validator details.

📚

Get Staked Account Rewards

GET /v4/data/staking/native/rewards
Explore Docs →
Returns historical staking rewards for Ethereum staking accounts.

📚

Get Staking Transactions

GET /v4/data/staking/native/transactions
Explore Docs →
Returns staking-related transactions, including stake, withdraw, and validator interactions.

What you can build

With Ethereum staking support, you can:

• Build Ethereum staking dashboards
• Track validator performance and rewards
• Power wallets and staking analytics tools

We’ve introduced configurable finality levels for subscriptions in the Tatum Notifications system across all supported EVM chains and Tron.

When creating a subscription, you can now choose when webhook notifications should be triggered:

• confirmed – Faster notifications with minimal confirmations
• final – Notifications only after full block finalisation

This allows developers to balance speed vs reliability depending on their application requirements.

📘

Create a subscription

POST /v4/subscription
Configure finality settings when creating your notification subscription.
Explore Docs →

Cosmos gRPC is available on Tatum for teams that want a more structured way to query chain data than plain JSON-based endpoints. Under the hood, Cosmos SDK modules expose Protobuf Query services, which means you work with strongly typed request and response messages instead of hand-rolling JSON payloads. That makes Cosmos a good fit for backends, indexers, and internal services that value predictable schemas, generated client code, and efficient binary transport.

📘

This is an important distinction from Solana Yellowstone gRPC: Cosmos gRPC is not a live event stream. It is designed for request-response queries, not subscriptions, and there are no streaming methods in this interface. If your use case is reading balances, delegations, validators, staking data, governance state, or other module-backed chain data with a typed API, Cosmos gRPC is the better framing.

Cosmos gRPC endpoint

Cosmos gRPC

▶️ Run in Postman 🚀 Get Started

↳ gRPC

https://cosmos-mainnet-grpc.gateway.tatum.io

🔍 Status 🕵️ Explorer

What you get

• Typed queries: Cosmos SDK modules expose Protobuf-based Query services, so request and response shapes are explicit.
• Smaller payloads: gRPC uses Protocol Buffers, which are typically more compact than JSON.
• Cleaner integrations: Generated gRPC clients reduce manual request building and response parsing across supported languages.
• Good fit for backend reads: Ideal for balances, staking, governance, validators, and other module state queries.
• REST parity when needed: Cosmos SDK can expose REST equivalents for gRPC query methods through gRPC-gateway.

Solana Yellowstone gRPC is live on Tatum. You can keep a single gRPC connection open to Mainnet and receive transactions, accounts, blocks, and slot updates as they happen, instead of hammering JSON-RPC on a timer.

Under the hood it follows the same Geyser-style streaming path many Solana operators already know. If your bot, indexer, or dashboard has been stuck waiting on poll intervals, this is the lane meant for you.

Solana Mainnet gRPC endpoint

Yellowstone gRPC (Mainnet)

▶️ Run in Postman 🚀 Get Started

↳ gRPC (Mainnet)

https://solana-mainnet-grpc.gateway.tatum.io

🔍 Status 🕵️ Explorer

What you get

• Speed: Push-style updates beat round-tripping the same RPC call every few hundred milliseconds.
• Payload: Messages use Protocol Buffers, which tends to be lighter than JSON for this kind of volume.
• Control: Subscribe to the account, slot, block, or transaction shape your product cares about.

Read next

• Data Streaming (gRPC & WebSockets) for how streaming fits next to RPC on Tatum.
• gRPC Data Streams for when gRPC is the right tool.
• Solana gRPC reference for auth, examples, and the Mainnet host spelled out step by step.

Looking for broader Solana coverage on Tatum? See Tatum Solana.

Need an API key first? Use the Tatum Dashboard.

If you want to test it now, import the Solana Mainnet gRPC Postman collection.
Need to validate endpoint behavior under load, reconnects, and edge cases? We prepared test suite for validating Solana Yellowstone gRPC (Geyser) endpoints. Tests all RPCs, streaming subscriptions, and edge cases, then reports pass/fail. 👉 Try our Solana GRPC Test repository.

We are excited to share that, we've introduced Webhook Templates in the Tatum Notifications system across all supported EVM chains and Tron. Templates allow developers to control the structure and format of webhook payloads sent by Tatum.

Supported formats include Enriched, Custom templates, and more. Each template returns a templateId that can be attached to a subscription to shape the webhook response.

📘

Create a Template

POST /v4/subscription/template
Create a custom notification template and use its templateId when creating or updating subscriptions.
Explore Docs →

Learn more in the Templates API.

We are updating the default webhook notification payload format for accounts created after March 19, 2026.

📘

Note

Existing accounts remain unaffected. All subscriptions for users who created an account before March 19, 2026, will continue using the legacy format unless explicitly updated.

What's Changed

New accounts created after March 19, 2026 will automatically receive a restructured webhook payload with clearer, more explicit fields, including from, to, tokenMetadata, and additional transaction context. This is a non breaking change for existing response as they stay on the old default response.

Why this matters

The new format provides:

• Explicit sender/recipient fields (from, to)
• Structured token metadata
• Additional transaction context (gas usage, timestamps, etc.)

Upgrading existing subscriptions

To switch an existing subscription to the new payload format, use the Update Subscription endpoint:

📘

Update a subscription

POST /v4/subscription/{id}
Configure conditions to trigger notifications only for relevant events.
Explore Docs →

Payload Comparison

Learn more about Templates.

Example: New payload format

{
  "data": {
    "kind": "transfer",
    "blockHash": "0x1234567890abcdef...",
    "blockNumber": 18500000,
    "blockTimestamp": 1699123456,
    "txId": "0xabcdef1234567890...",
    "currency": "ETH",
    "txTimestamp": 1699123456,
    "from": "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
    "to": "0x8ba1f109551bD432803012645Hac136c",
    "value": "1000000000000000000",
    "contractAddress": "0xA0b86a33E6441b8c4C8C0C8C0C8C0C8C0C8C0C8C0C",
    "tokenId": "12345",
    "additionalData": {
      "gasUsed": "21000",
      "gasPrice": "20000000000"
    },
    "tokenMetadata": {
      "type": "nft",
      "decimals": 0,
      "symbol": "NFT",
      "name": "My NFT",
      "uri": "https://api.example.com/metadata/12345"
    },
    "subscriptionId": "64f1a2b3c4d5e6f7g8h9i0j1",
    "subscriptionType": "ADDRESS_EVENT"
  },
  "location": "...",
  "scheme": "..."
}

Tatum v3 Blockchain API Endpoints have become deprecated in favour of the new v4 Blockchains API Endpoints .

v4 Blockchains API Endpoints bring schema standardisation and improved functionality across chains, backed by a robust, unified and scalable infrastructure built for long term support.

Affected customers are encouraged to begin planning their migration as soon as possible to avoid service disruptions.

⏰ End of Life Deadline

❗️

Important

v3 Blockchain API Endpoints will remain operational until May 31, 2026, after which the underlying infrastructure will be decommissioned.

🔄 Migration Guides

We've prepared comprehensive migration guides to help you transition from v3 to v4 Blockchain API Endpoints.

Visit our Blockchains API Migration Path in the Guides section for:

• Step-by-step migration instructions for each endpoint

• v3 to v4 endpoint mapping references

We’ve released the Blockchains API, a new unified interface for querying blockchain data across multiple networks and architectures.

Instead of dealing with different RPC APIs and response formats for each blockchain, developers can now retrieve blocks, transactions, balances, and mempool data using a single standardized API format.

It works across multiple blockchain architectures, including:

• EVM chains: Ethereum, Polygon, BNB Smart Chain, Arbitrum, Optimism, Base,...
• UTXO chains: Bitcoin, Litecoin, Dogecoin, Bitcoin Cash
• Emerging ecosystems: – including networks like Berachain, Monad, Unichain,...

This unified approach makes it easier to build multi-chain applications, analytics platforms, explorers, and monitoring tools without needing to implement chain-specific logic.

Available Blockchain API Endpoints

Block Data

Endpoints for retrieving blockchain block information.

• Get current block height – Retrieve the latest block height for a supported blockchain.
• Get block by hash or height – Retrieve detailed information about a specific block.
• Get block hash by block number – Retrieve the block hash using a block number.

Transactions

Endpoints for retrieving transaction-level data across supported blockchains.

• Get transaction by hash – Retrieve transaction details for EVM and UTXO blockchains.
• Get internal transactions by address – Retrieve internal transactions for an address on supported EVM chains.
• Get outgoing transaction count – Retrieve the number of outgoing transactions (+pending) for a given address.
• Get mempool transaction hashes – Retrieve hashes of pending transactions from the mempool.

Address & Balance Data

Endpoints for retrieving address-level blockchain data.

• Get native balance – Retrieve the native balance of an address across supported blockchains.
• Get native balance (batch) – Retrieve balances for multiple addresses in a single request.

UTXO Data

Endpoints specific to UTXO-based blockchains such as Bitcoin, Litecoin, Dogecoin, and Bitcoin Cash.

• Get UTXO info by tx hash and index – Retrieve details of a specific transaction output.
• Get transaction history (UTXO) – Retrieve transaction history for an address.
• Get transaction history (UTXO) batch – Retrieve transaction history for multiple addresses in a single request.

Why it matters?

Working with multiple blockchains often means dealing with different APIs, response formats, and protocol quirks.

The Blockchains API simplifies this by providing:

• Unified multi-chain interface for querying blockchain data
• Enriched data in compare to standard raw RPC data
• Standardized response format across supported blockchains
• Direct access to raw blockchain data including blocks and transactions
• Scalable infrastructure designed for high-volume data queries

We’re expanding our Tron Nile coverage with full JSON-RPC support, making it easier to integrate, test, and debug Tron workflows using a standard RPC interface.

Tron Nile is Tron’s public test network, built to mirror mainnet behavior while keeping development risk (and cost) low. It’s commonly used to validate smart contracts, transaction flows, and event indexing before production rollout. With Nile, teams can safely iterate on dApps, wallets, and backend services – then transition to mainnet with confidence.

Tron RPC networks

▶️ Run in Postman 🚀 Get Started

💎

Tron Mainnet

🕵️ Explorer

↳ JSON-RPC

https://tron-mainnet.gateway.tatum.io/jsonrpc

🔍 Status

↳ HTTP API

https://tron-mainnet.gateway.tatum.io/wallet

🔍 Status

↳ Solidity HTTP API

https://tron-mainnet.gateway.tatum.io/walletsolidity

🔍 Status

✨

Tron Shasta

🕵️ Explorer

↳ JSON-RPC

https://tron-shasta.gateway.tatum.io/jsonrpc

🔍 Status

↳ HTTP API

https://tron-shasta.gateway.tatum.io/wallet

🔍 Status

↳ Solidity HTTP API

https://tron-shasta.gateway.tatum.io/walletsolidity

🔍 Status

✨

Tron Nile

🕵️ Explorer

↳ JSON-RPC

https://tron-nile.gateway.tatum.io/jsonrpc

🔍 Status

↳ HTTP API

https://tron-nile.gateway.tatum.io/wallet

🔍 Status

↳ Solidity HTTP API

https://tron-nile.gateway.tatum.io/walletsolidity

🔍 Status