Skip To Content

Blockdaemon Documentation

Supported Native Methods

With Ubiquity Native RPC Access API, you can interact with multiple major protocols through their own native APIs.

See the sections below to find:

  • Native methods available for each protocol
  • Information on how to access native APIs
  • Usage examples

Please Note: When calling a method that is not available or does not exist, you will receive the following error message: method not allowed.

Supported Methods by Protocol

Acala
Algorand
Avalanche
Bitcoin
Bitcoin Cash
Celo
Cronos
Dogecoin
Ethereum
Karura
Kusama
Litecoin
NEAR
Oasis
Optimism
Polkadot
Polygon
Solana
Stellar
Tezos
XRP


Acala

In this section you will find out which Acala methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Acala Mainnet

Supported Substrate RPC Methods

You can access Acala via Substrate RPC API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

chain

childstate

offchain

payment

state

system

How To Access Acala via Substrate RPC API

Step 1. To access Acala via the available Substrate RPC methods, use the Ubiquity native access endpoint with /para-http-rpc at the end:

Network: Acala Mainnet
Request Type: POST

https://svc.blockdaemon.com/acala/mainnet/native/para-http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Substrate RPC method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request for Substrate RPC API

Here is a cURL example for using system_syncState to get the chainspec running the node, with a sync state, in Acala Mainnet:

curl -X POST \
https://svc.blockdaemon.com/acala/mainnet/native/para-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "system_syncState", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "startingBlock": 1600016,
        "currentBlock": 1655014,
        "highestBlock": 1655013
    },
    "id": 1
}

Supported Substrate Sidecar Methods

You can access Acala via Substrate Sidecar API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

accounts

  • GET /accounts/{accountId}/asset-approvals
  • GET /accounts/{accountId}/asset-balances
  • GET /accounts/{accountId}/balance-info
  • GET /accounts/{accountId}/staking-info
  • GET /accounts/{accountId}/staking-payouts
  • GET /accounts/{accountId}/validate
  • GET /accounts/{accountId}/vesting-info

blocks

  • GET /blocks
  • GET /blocks/head
  • GET /blocks/head/header
  • GET /blocks/{blockId}
  • GET /blocks/{blockId}/extrinsics/{extrinsicIndex}
  • GET /blocks/{blockId}/header

node

  • GET /node/network
  • GET /node/transaction-pool
  • GET /node/version

pallets

  • GET /pallets/assets/{assetId}/asset-info
  • GET /pallets/{palletId}/storage
  • GET /pallets/{palletId}/storage/{storageItemId}

runtime

  • GET /runtime/code
  • GET /runtime/metadata
  • GET /runtime/spec
  • POST /transaction

transaction

  • POST /transaction/dry-run
  • POST /transaction/fee-estmate
  • GET /transaction/material

paras

  • GET /paras
  • GET /paras/auctions/current
  • GET /paras/crowdloans
  • GET /paras/leases/current
  • GET /paras/{paraId}/crowdloan-info
  • GET /paras/{paraId}/lease-info

How To Access Acala via Substrate Sidecar API

Step 1. To access the available Substrate Sidecar methods, use the Ubiquity native access endpoint with /parachain at the end:

Network: Acala Mainnet
Request Type: GET / POST

https://svc.blockdaemon.com/acala/mainnet/native/parachain

Step 3. Add a Substrate Sidecar method at the end of the query:

https://svc.blockdaemon.com/acala/mainnet/native/parachain/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request for Substrate Sidecar API

Here is a cURL example for using GET /blocks/head/header to get the header of the most recently finalized block in Acala Mainnet:

curl -X GET \
https://svc.blockdaemon.com/acala/mainnet/native/parachain/blocks/head/header \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "parentHash": "0xe4d87b0d0330fc9e765c8f3b14dddb9805c653aa4e8b9a3f6c3431070d5f2db6",
    "number": "1655012",
    "stateRoot": "0x5950ea6023e98916c9ed60ec942553a9932a8733b1dfd8f52a52c1d9e37fd60d",
    "extrinsicsRoot": "0xa391d3be412cc8328f8b007ae2829335320293a589abfce0046ee58a4d6b8e3b",
    "digest": {
        "logs": [
            {
                "preRuntime": [
                    "0x61757261",
                    "0x6a9d3f0800000000"
                ]
            },
            {
                "seal": [
                    "0x61757261",
                    "0x9e7d3c52bc61abcf7560292ce41bb2da5242d84bab8365a5e54770f0a38fd15cb622cfe1d48844e2832ff314cb8376803185d33cc2283c4f39bc4922496ed58b"
                ]
            }
        ]
    }
}

Avalanche

In this section you will find out which Avalanche methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Avalanche Mainnet

Supported Avalanche Methods

You can access both Ethereum methods and Avalanche-specific methods. Learn more:

Ethereum C-Chain Methods

Avalanche C-Chain (AVAX) Methods

Avalanche Health Methods

Avalanche Info Methods

How To Access Avalanche API

Step 1. To access the available Avalanche methods, use the following Ubiquity native access endpoint:

Network: Avalanche Mainnet
Request Type: POST

https://svc.blockdaemon.com/avalanche/mainnet/native/YOUR_PATH_PARAMETER

Depending on the method, add one of the following path parameters at the end:

Method Path parameter
Ethereum C-Chain ext-bc-c-eth-http-rpc
Avalanche C-Chain (AVAX) ext-bc-c-avax-http-rpc
Avalanche Health ext-health-http-rpc
Avalanche Info ext-info-http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Avalanche method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Requests

Example 1: Ethereum C-Chain Methods

Here is a cURL example for using eth_blockNumber to get the current block number in Avalanche Mainnet:

curl -X \
POST https://svc.blockdaemon.com/avalanche/mainnet/native/ext-bc-c-eth-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x1335404"
}

Example 2: Avalanche C-Chain (AVAX) Methods

Here is a cURL example for using avax.getUTXOs to get the UTXOs that reference a given address in Avalanche Mainnet:

curl -X \
POST https://svc.blockdaemon.com/avalanche/mainnet/native/ext-bc-c-avax-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "avax.getUTXOs", "params": {"addresses": ["C-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5"], "sourceChain": "X"}}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "numFetched": "0",
        "utxos": [],
        "endIndex": {
            "address": "C-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
            "utxo": "11111111111111111111111111111111LpoYY"
        },
        "encoding": "hex"
    },
    "id": 1
}

Example 3: Avalanche Health Methods

Here is a cURL example for using health.health to get the last set of health check results in Avalanche Mainnet:

curl -X \
POST https://svc.blockdaemon.com/avalanche/mainnet/native/  ext-health-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "health.health", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "checks": {
            "C": {
                "message": {
                    "consensus": {
                        "longestRunningBlock": "51.804748ms",
                        "outstandingBlocks": 1
                    },
                    "vm": null
                },
                "timestamp": "2022-09-22T16:00:01.043148255Z",
                "duration": 7344
            },
            {...more items...}
        },
        "healthy": true
    },
    "id": 1
}

Example 4: Avalanche Info Methods

Here is a cURL example for using info.getTxFee to get the fees of the Avalanche Mainnet:

curl -X \
POST https://svc.blockdaemon.com/avalanche/mainnet/native/  ext-info-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "info.getTxFee", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "txFee": "1000000",
        "creationTxFee": "10000000",
        "createAssetTxFee": "10000000",
        "createSubnetTxFee": "1000000000",
        "transformSubnetTxFee": "1000000000",
        "createBlockchainTxFee": "1000000000",
        "addPrimaryNetworkValidatorFee": "0",
        "addPrimaryNetworkDelegatorFee": "0",
        "addSubnetValidatorFee": "1000000",
        "addSubnetDelegatorFee": "1000000"
    },
    "id": 1
}

Bitcoin

In this section you will find out which Bitcoin methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Bitcoin Mainnet
  • Bitcoin Testnet

Supported Bitcoin Methods

You can find Bitcoin API documentation here: Bitcoin API reference

The following methods are allowed in Ubiquity Native Access API:

Blockchain RPCs

Rawtransactions RPCs

Util RPCs

How To Access Bitcoin API

Step 1. To access the available Bitcoin methods, use the following Ubiquity native access endpoints:

Network: Bitcoin Mainnet
Request Type: POST

https://svc.blockdaemon.com/bitcoin/mainnet/native

Network: Bitcoin Testnet
Request Type: POST

https://svc.blockdaemon.com/bitcoin/testnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Bitcoin method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using getblockcount to get the height of the most-work fully-validated chain in Bitcoin Mainnet:

curl -X POST \
https://svc.blockdaemon.com/bitcoin/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "getblockcount", "params": []}'

The following is a typical response you will get:

{
    "result": 748958,
    "error": null,
    "id": 1
}

Algorand

In this section you will find out which Algorand methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Algorand Mainnet

Supported Algod Methods

You can access Algorand via Algod REST API. Learn more: Algod REST API reference

The following methods are allowed in Ubiquity Native Access API:

How To Access Algorand via Algod API

Step 1. To access Algorand via the available Algod methods, use the following Ubiquity native access endpoint:

Network: Algorand Mainnet
Request Type: GET / POST / DELETE

https://svc.blockdaemon.com/algorand/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Add an Algorand method at the end of the query:

https://svc.blockdaemon.com/algorand/mainnet/YOUR_METHOD

Example Request for Algod API

Here is a cURL example for using GET /v2/ledger/supply to get the current supply reported by the ledger in Algorand Mainnet:

curl -X GET \
https://svc.blockdaemon.com/algorand/mainnet/native/v2/ledger/supply \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "current_round": 22988124,
    "online-money": 2388091813708583,
    "total-money": 7314443768632736
}

Supported Indexer Methods

You can access Algorand via Indexer REST API. Learn more: Indexer REST API reference

The following methods are allowed in Ubiquity Native Access API:

How To Access Algorand via Indexer API

Step 1. To access Algorand via the available Indexer methods, use the Ubiquity native access endpoint with /indexer at the end:

Network: Algorand Mainnet
Request Type: GET

https://svc.blockdaemon.com/algorand/mainnet/native/indexer

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Add an Algorand method at the end of the query:

https://svc.blockdaemon.com/algorand/mainnet/indexer/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request for Indexer API

Here is a cURL example for using GET /health to get the status information of Algorand Mainnet:

curl -X GET \
https://svc.blockdaemon.com/algorand/mainnet/native/indexer/health \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "data": {
        "migration-required": false,
        "read-only-mode": true
    },
    "db-available": true,
    "is-migrating": false,
    "message": "22987920",
    "round": 22987920,
    "version": "2.12.1"
}

Bitcoin Cash

In this section you will find out which Bitcoin Cash methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Bitcoin Cash Mainnet
  • Bitcoin Cash Testnet

Supported Bitcoin Cash Methods

You can find Bitcoin Cash API documentation here: Bitcoin Cash API reference

The following methods are allowed in Ubiquity Native Access API:

Blockchain RPCs

Rawtransactions RPCs

Util RPCs

How To Access Bitcoin Cash API

Step 1. To access the available Bitcoin Cash methods, use the following Ubiquity native access endpoints:

Network: Bitcoin Cash Mainnet
Request Type: POST

https://svc.blockdaemon.com/bitcoincash/mainnet/native

Network: Bitcoin Cash Testnet
Request Type: POST

https://svc.blockdaemon.com/bitcoincash/testnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Bitcoin Cash method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using getblockcount to get the height of the most-work fully-validated chain in Bitcoin Cash Mainnet:

curl -X POST \
https://svc.blockdaemon.com/bitcoincash/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "getblockcount", "params": []}'

The following is a typical response you will get:

{
    "result": 752780,
    "error": null,
    "id": 1
}

Celo

In this section you will find out which Celo methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Celo Mainnet

Supported Celo Methods

You can access Celo via Ethereum API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

How To Access Celo API

Step 1. To access the available Celo methods, use the Ubiquity native access endpoint with /http-rpc at the end:

Network: Celo Mainnet
Request Type: POST

https://svc.blockdaemon.com/celo/mainnet/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Celo method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using eth_blockNumber to get the current block number in Celo Mainnet:

curl -X \
POST https://svc.blockdaemon.com/celo/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0xe167fc"
}

Cronos

In this section you will find out which Cronos methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Cronos Mainnet

Supported Cronos Methods

You can access Cronos via Ethereum API. Learn more: Ethereum API reference

How To Access Cronos via Ethereum API

Step 1. To access the available Ethereum methods, use the Ubiquity native access endpoint with http-rpc at the end:

Network: Cronos Mainnet
Request Type: POST

https://svc.blockdaemon.com/cronos/mainnet/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Ethereum method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using eth_blockNumber to get the current block number in Cronos Mainnet:

curl -X \
POST https://svc.blockdaemon.com/cronos/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x22105c3"
}

Supported Tendermint Methods

You can access Cronos via Tendermint RPC API. Learn more: Tendermint API reference

How To Access Cronos via Tendermint RPC API

Step 1. To access the available Tendermint methods, use the Ubiquity native access endpoint with tendermint-rpc at the end:

Network: Cronos Mainnet
Request Type: POST

https://svc.blockdaemon.com/cronos/mainnet/native/tendermint-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Tendermint method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x558153"
}}

Example Request

Here is a cURL example for using health to get a node heartbeat for Cronos Mainnet:

curl -X \
POST https://svc.blockdaemon.com/cronos/mainnet/native/tendermint-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "health", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": {}
}

How To Access Cronos via Tendermint REST API

Step 1. To access the available Tendermint methods, use the Ubiquity native access endpoint with tendermint-rest at the end:

Network: Cronos Mainnet
Request Type: GET

https://svc.blockdaemon.com/cronos/mainnet/native/tendermint-rest

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Tendermint method at the end of the query:

https://svc.blockdaemon.com/cronos/mainnet/native/tendermint-rest/YOUR_METHOD

Example Request

Here is a cURL example for using health to get a node heartbeat for Cronos Mainnet:

curl -X GET \
https://svc.blockdaemon.com/cronos/mainnet/native/tendermint-rest/health \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": {}
}

Dogecoin

In this section you will find out which Dogecoin methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Dogecoin Mainnet
  • Dogecoin Testnet

Supported Dogecoin Methods

Dogecoin uses the Bitcoin API. Learn more: Bitcoin API reference

The following methods are allowed in Ubiquity Native Access API:

Blockchain RPCs

Rawtransactions RPCs

Util RPCs

How To Access Dogecoin API

Step 1. To access the available Dogecoin methods, use the following Ubiquity native access endpoints:

Network: Dogecoin Mainnet
Request Type: POST

https://svc.blockdaemon.com/dogecoin/mainnet/native

Network: Dogecoin Testnet
Request Type: POST

https://svc.blockdaemon.com/dogecoin/testnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Dogecoin method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using getblockcount to get the height of the most-work fully-validated chain in Dogecoin Mainnet:

curl -X POST \
https://svc.blockdaemon.com/dogecoin/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "getblockcount", "params": []}'

The following is a typical response you will get:

{
    "result": 4343995,
    "error": null,
    "id": 1
}

Ethereum

In this section you will find out which Ethereum methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Ethereum Mainnet
  • Goerli Testnet
  • Ropsten Testnet

Supported Ethereum Methods

You can find Ethereum API documentation here: Ethereum API reference

The following methods are allowed in Ubiquity Native Access API:

How To Access Ethereum API

Step 1. To access the available Ethereum methods, use the following Ubiquity native access endpoints:

Network: Ethereum Mainnet
Request Type: POST

https://svc.blockdaemon.com/ethereum/mainnet/native

Network: Ethereum Goerli
Request Type: POST

https://svc.blockdaemon.com/ethereum/goerli/native

Network: Ethereum Ropsten
Request Type: POST

https://svc.blockdaemon.com/ethereum/ropsten/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Ethereum method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using eth_blockNumber to get the current block number in Ethereum Mainnet:

curl -X POST \
https://svc.blockdaemon.com/ethereum/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0xe9c344"
}

Karura

In this section you will find out which Karura methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Karura Mainnet

Supported Substrate RPC Methods

You can access Karura via Substrate RPC API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

chain

childstate

contracts

GrandpaAPI

mmr

offchain

payment

rpc

state

syncstate

system

How To Access Karura via Substrate RPC API

Step 1. To access Karura via the available Substrate RPC methods, use the Ubiquity native access endpoint with /para-http-rpc at the end:

Network: Karura Mainnet
Request Type: POST

https://svc.blockdaemon.com/karura/mainnet/native/para-http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Substrate RPC method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request for Substrate RPC API

Here is a cURL example for using system_syncState to get the chainspec running the node, with a sync state, in Karura Mainnet:

curl -X POST \
https://svc.blockdaemon.com/karura/mainnet/native/para-http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "system_syncState", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "startingBlock": 2414982,
        "currentBlock": 2461542,
        "highestBlock": 2461542
    },
    "id": 1
}

Supported Substrate Sidecar Methods

You can access Karura via Substrate Sidecar API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

accounts

  • GET /accounts/{accountId}/asset-approvals
  • GET /accounts/{accountId}/asset-balances
  • GET /accounts/{accountId}/balance-info
  • GET /accounts/{accountId}/staking-info
  • GET /accounts/{accountId}/staking-payouts
  • GET /accounts/{accountId}/validate
  • GET /accounts/{accountId}/vesting-info

blocks

  • GET /blocks
  • GET /blocks/head
  • GET /blocks/head/header
  • GET /blocks/{blockId}
  • GET /blocks/{blockId}/extrinsics/{extrinsicIndex}
  • GET /blocks/{blockId}/header

node

  • GET /node/network
  • GET /node/transaction-pool
  • GET /node/version

pallets

  • GET /pallets/assets/{assetId}/asset-info
  • GET /pallets/staking/progress
  • GET /pallets/{palletId}/storage
  • GET /pallets/{palletId}/storage/{storageItemId}

runtime

  • GET /runtime/code
  • GET /runtime/metadata
  • GET /runtime/spec

paras

  • GET /paras
  • GET /paras/auctions/current
  • GET /paras/crowdloans
  • GET /paras/leases/current
  • GET /paras/{paraId}/crowdloan-info
  • GET /paras/{paraId}/lease-info

transaction

  • POST /transaction
  • POST /transaction/dry-run
  • POST /transaction/fee-estmate
  • GET /transaction/material

How To Access Karura via Substrate Sidecar API

Step 1. To access the available Substrate Sidecar methods, use the Ubiquity native access endpoint with /parachain at the end:

Network: Karura Mainnet
Request Type: GET / POST

https://svc.blockdaemon.com/karura/mainnet/native/parachain

Step 3. Add a Substrate Sidecar method at the end of the query:

https://svc.blockdaemon.com/karura/mainnet/native/parachain/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request for Substrate Sidecar API

Here is a cURL example for using GET /blocks/head/header to get the header of the most recently finalized block in Karura Mainnet:

curl -X GET \
https://svc.blockdaemon.com/karura/mainnet/native/parachain/blocks/head/header \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "parentHash": "0x46a11082a6696153f35414e2f62d2258d4509d6ab6ca7a03728dcc707efa053e",
    "number": "2461599",
    "stateRoot": "0xd14cbc39637c61537f54f759ef2b5450250cf171901858ae23a2cb1f9ada7d1c",
    "extrinsicsRoot": "0xca110fe695be5a5b2878508e2faadf82bbcdf117f06e5432334d262bdfb5091b",
    "digest": {
        "logs": [
            {
                "preRuntime": [
                    "0x61757261",
                    "0x659d3f0800000000"
                ]
            },
            {
                "seal": [
                    "0x61757261",
                    "0x3e30c6cc4394f19535ff198997e886f745e813ea9ba025403d27797d39a0356e8af719a793e58698441abbc1214df4ed81fb7194d01846af2aaf430c25513083"
                ]
            }
        ]
    }
}

Kusama

In this section you will find out which Kusama methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Kusama Mainnet

Supported Substrate RPC Methods

You can access Kusama via Substrate RPC API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

chain

childstate

contracts

GrandpaApi

mmr

offchain

payment

rpc

state

syncstate

system

How To Access Kusama via Substrate RPC API

Step 1. To access Kusama via the available Substrate RPC methods, use the Ubiquity native access endpoint with /http-rpc at the end:

Network: Kusama Mainnet
Request Type: POST

https://svc.blockdaemon.com/kusama/mainnet/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Substrate RPC method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request for Substrate RPC API

Here is a cURL example for using system_syncState to get the chainspec running the node, with a sync state, in Kusama Mainnet:

curl -X POST \
https://svc.blockdaemon.com/kusama/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "system_syncState", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "startingBlock": 11614494,
        "currentBlock": 11616224
    },
    "id": 1
}

Supported Substrate Sidecar Methods

You can access Kusama via Substrate Sidecar API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

accounts

  • GET /accounts/{accountId}/asset-approvals
  • GET /accounts/{accountId}/asset-balances
  • GET /accounts/{accountId}/balance-info
  • GET /accounts/{accountId}/staking-info
  • GET /accounts/{accountId}/staking-payouts
  • GET /accounts/{accountId}/validate
  • GET /accounts/{accountId}/vesting-info

runtime

  • GET /blocks
  • GET /blocks/head
  • GET /blocks/head/header
  • GET /blocks/{blockId}
  • GET /blocks/{blockId}/extrinsics/{extrinsicIndex}
  • GET /blocks/{blockId}/header

node

  • GET /node/network
  • GET /node/transaction-pool
  • GET /node/version

pallets

  • GET /pallets/assets/{assetId}/asset-info
  • GET /pallets/staking/progress
  • GET /pallets/{palletId}/storage
  • GET /pallets/{palletId}/storage/{storageItemId}

runtime

  • GET /runtime/code
  • GET /runtime/metadata
  • GET /runtime/spec

paras

  • GET /paras
  • GET /paras/auctions/current
  • GET /paras/crowdloans
  • GET /paras/leases/current
  • GET /paras/{paraId}/crowdloan-info
  • GET /paras/{paraId}/lease-info

transaction

  • POST /transaction
  • POST /transaction/dry-run
  • POST /transaction/fee-estmate
  • GET /transaction/material

How To Access Kusama via Substrate Sidecar API

Step 1. To access the available Substrate Sidecar methods, use the following Ubiquity native access endpoint:

Network: Kusama Mainnet
Request Type: GET / POST

https://svc.blockdaemon.com/kusama/mainnet/native

Step 3. Add a Substrate Sidecar method at the end of the query:

https://svc.blockdaemon.com/kusama/mainnet/native/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request for Substrate Sidecar API

Here is a cURL example for using GET /blocks/head/header to get the header of the most recently finalized block in Kusama Mainnet:

curl -X GET \
https://svc.blockdaemon.com/kusama/mainnet/native/blocks/head/header \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "parentHash": "0xd2321a7ffc86663a202b57f3db042a6b90ea4617d9fd64ad153af36aa62c9274",
    "number": "14017588",
    "stateRoot": "0x0ad4d1716a77421bb2e254d0df548fc1c5ad6081057be9797534b02ef394daa8",
    "extrinsicsRoot": "0xde3f7437ff01e80efdd23c3172b2171ad40852dc7e881c4fff0072b097f1b650",
    "digest": {
        "logs": [
            {
                "preRuntime": [
                    "0x42414245",
                    "0x03d6000000590b7f1000000000964cad717dc1614e72ea13894665e656e7dc2e16fe8a5397fb7b71170644a300c2344d0914b407b0fd0c7ae72403025946a2be45eeadd9339c516ccf05f5c80bb7e32a535aa0aa82d015b315ebc99d100e512976d9a2c9aba8d7b6d15793cd0b"
                ]
            },
            {
                "seal": [
                    "0x42414245",
                    "0x68778ac227550d204f3c541dd07bc3266b41a0d0ca4dc6e5a06cb4c954585d53a61e56d2be99190fa24d6c8e6cb24ac0870ebb3aa325fae8817c7d46c27ca181"
                ]
            }
        ]
    }
}

Litecoin

In this section you will find out which Litecoin methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Litecoin Mainnet
  • Litecoim Testnet

Supported Litecoin Methods

Litecoin uses the Bitcoin API. Learn more: Bitcoin API reference

The following methods are allowed in Ubiquity Native Access API:

Blockchain RPCs

Rawtransactions RPCs

Util RPCs

How To Access Litecoin API

Step 1. To access the available Litecoin methods, use the following Ubiquity native access endpoints:

Network: Litecoin Mainnet
Request Type: POST

https://svc.blockdaemon.com/litecoin/mainnet/native

Network: Litecoin Testnet
Request Type: POST

https://svc.blockdaemon.com/litecoin/testnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Litecoin method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using getblockcount to get the height of the most-work fully-validated chain in Litecoin Mainnet:

curl -X POST \
https://svc.blockdaemon.com/litecoin/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "getblockcount", "params": []}'

The following is a typical response you will get:

{
    "result": 2313630,
    "error": null,
    "id": 1
}

NEAR

In this section you will find out which NEAR methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • NEAR Mainnet

Supported NEAR Methods

You can find NEAR API documentation here: NEAR API reference

The following methods are allowed in Ubiquity Native Access API:

Access Keys

Accounts / Contracts

Block / Chunk

Gas

Protocol

Network

Transactions

How To Access NEAR API

Step 1. To access the available NEAR methods, use the following Ubiquity native access endpoint:

Network: NEAR Mainnet
Request Type: POST

https://svc.blockdaemon.com/near/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a NEAR method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using status to get status information for nodes and validators in NEAR Mainnet:

curl -X POST \
https://svc.blockdaemon.com/near/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "status", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "chain_id": "mainnet",
        "latest_protocol_version": 55,
        "protocol_version": 55,
        "rpc_addr": "0.0.0.0:3030",
        "sync_info": {
            "earliest_block_hash": "9VCLy3EaCokgrnqeQNyNcY7B4bdLVk5LM2vvHRQYuEJE",
            "earliest_block_height": 71915612,
            "earliest_block_time": "2022-08-13T12:51:39.002561384Z",
            "epoch_id": "HF8QqSZs3LGsTg625y8MBEqbFwjHd8daM9hrgDb4QVUL",
            "epoch_start_height": 72114690,
            "latest_block_hash": "6gKCRSq9y3SErvbvmJ1dSMKjxb2JpL3g69j3eR4f7G8m",
            "latest_block_height": 72123152,
            "latest_block_time": "2022-08-16T10:04:45.200886611Z",
            "latest_state_root": "HLryscwpjBMsVvBeoAHpVq3ZbYHSJG2djL6HmY9psRLZ",
            "syncing": false
        },
        "validator_account_id": null,
        "validators": [
            {
                "account_id": "bzam6yjpnfnxsdmjf6pw.poolv1.near",
                "is_slashed": false
            },
            { ...more validators... }
        ],
        "version": {
            "build": "crates-0.14.0-149-gef8862918-modified",
            "rustc_version": "1.61.0",
            "version": "1.28.0"
        }
    },
    "id": 1
}

Oasis

In this section you will find out which Oasis methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Oasis Mainnet

Supported Oasis Methods

You can access Oasis via Rosetta API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

How To Access Oasis API

Step 1. To access the available Oasis methods, use the following Ubiquity native access endpoint:

Network: Oasis Mainnet
Request Type: POST

https://svc.blockdaemon.com/oasis/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Oasis method at the end of the query:

https://svc.blockdaemon.com/oasis/mainnet/native/YOUR_METHOD

Step 4. Specify the data required by the method in the request body.

Example Requests

Example 1. Here is a cURL example for using POST /network/list to get the network identifier of Oasis Mainnet:

curl -X POST \
https://svc.blockdaemon.com/oasis/mainnet/native/network/list \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"metadata": {}}'

The following is a typical response you will get:

{
    "network_identifiers": [
        {
            "blockchain": "Oasis",
            "network": "b11b369e0da5bb230b220127f5e7b242d385ef8c6f54906243f30af63c815535"
        }
    ]
}

Example 2. Here is a cURL example for using POST /network/status to get the current status of Oasis Mainnet:

curl -X POST \
https://svc.blockdaemon.com/oasis/mainnet/native/network/status \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"metadata": {}, "network_identifier": {"blockchain": "Oasis", "network": "b11b369e0da5bb230b220127f5e7b242d385ef8c6f54906243f30af63c815535"}}'

The following is a typical response you will get:

{
    "current_block_identifier": {
        "index": 9985468,
        "hash": "b74c203aedecfd9f15e7da82cf85bad904a4f51734e2bb0e93ebb449c7ef02bf"
    },
    "current_block_timestamp": 1661160818000,
    "genesis_block_identifier": {
        "index": 8048956,
        "hash": "0000000000000000000000000000000000000000000000000000000000000000"
    },
    "oldest_block_identifier": {
        "index": 9284103,
        "hash": "8bdd726805da09c493e532e5d2a9b6124d5cfc2d1e4209ddd722c7fa0974f2d8"
    },
    "peers": [
        {
            "peer_id": "[email protected]:26656"
        },
        { ...more items... }
    ]
}

Example 3. Here is a cURL example for using POST /block to get a block by index in Oasis Mainnet:

curl -X POST \
https://svc.blockdaemon.com/oasis/mainnet/native/block \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"metadata": {}, "network_identifier": {"blockchain": "Oasis", "network": "b11b369e0da5bb230b220127f5e7b242d385ef8c6f54906243f30af63c815535"}, "block_identifier": {"index": 9985468}}'

The following is a typical response you will get:

{
    "block": {
        "block_identifier": {
            "index": 9985468,
            "hash": "b74c203aedecfd9f15e7da82cf85bad904a4f51734e2bb0e93ebb449c7ef02bf"
        },
        "parent_block_identifier": {
            "index": 9985467,
            "hash": "ca81d8f4e70bee34fd2be0b76713824d0d9bb85975f1d39c8b72564ea3a1c7d9"
        },
        "timestamp": 1661160818000,
        "transactions": [
            {
                "transaction_identifier": {
                    "hash": "5aa588eddf7c862b1d4f6f775f8b0322a67ca07f0d50a71c4948406fd28010f7"
                },
                "operations": []
            },
            { ...more items... }
        ],
        "metadata": {
            "epoch": 16629
        }
    }
}

Optimism

In this section you will find out which Optimism methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Optimism Mainnet

Supported Optimism Methods

You can access Optimism via Ethereum API. Learn more:

The following methods are allowed in Ubiquity Native Access API:

How To Access Optimism API

Step 1. To access the available Optimism methods, use the Ubiquity native access endpoint with /http-rpc at the end:

Network: Optimism Mainnet
Request Type: POST

https://svc.blockdaemon.com/optimism/mainnet/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Optimism method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using eth_blockNumber to get the current block number in Optimism Mainnet:

curl -X \
POST https://svc.blockdaemon.com/optimism/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x17ba022"
}

Polkadot

In this section you will find out which Polkadot methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Polkadot Mainnet
  • Polkadot Westend

Supported Substrate RPC Methods

You can access Polkadot via Substrate RPC API. Learn more: Substrate RPC API reference

The following methods are allowed in Ubiquity Native Access API:

chain

childstate

contracts

GrandpaApi

mmr

offchain

payment

rpc

state

syncstate

system

How To Access Polkadot via Substrate RPC API

Step 1. To access the available Substrate RPC methods, use the Ubiquity native access endpoint with /http-rpc at the end:

Network: Polkadot Mainnet
Request Type: POST

https://svc.blockdaemon.com/polkadot/mainnet/native/http-rpc

Network: Polkadot Westend
Request Type: POST

https://svc.blockdaemon.com/polkadot/westend/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Substrate RPC method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request for Substrate RPC API

Here is a cURL example for using system_syncState to get the chainspec running the node, with a sync state, in Polkadot Mainnet:

curl -X POST \
https://svc.blockdaemon.com/polkadot/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "system_syncState", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": {
        "startingBlock": 11614877,
        "currentBlock": 11615160
    },
    "id": 1
}

Supported Substrate Sidecar Methods

You can access Polkadot via Substrate Sidecar API. Learn more: Substrate Sidecar API reference

The following methods are allowed in Ubiquity Native Access API:

accounts

  • GET /accounts/{accountId}/asset-approvals
  • GET /accounts/{accountId}/asset-balances
  • GET /accounts/{accountId}/balance-info
  • GET /accounts/{accountId}/staking-info
  • GET /accounts/{accountId}/staking-payouts
  • GET /accounts/{accountId}/validate
  • GET /accounts/{accountId}/vesting-info

blocks

  • GET /blocks
  • GET /blocks/head
  • GET /blocks/head/header
  • GET /blocks/{blockId}
  • GET /blocks/{blockId}/extrinsics/{extrinsicIndex}
  • GET /blocks/{blockId}/header

blocks

  • GET /node/network
  • GET /node/transaction-pool
  • GET /node/version

pallets

  • GET /pallets/assets/{assetId}/asset-info
  • GET /pallets/staking/progress
  • GET /pallets/{palletId}/storage
  • GET /pallets/{palletId}/storage/{storageItemId}

runtime

  • GET /runtime/code
  • GET /runtime/metadata
  • GET /runtime/spec

paras

  • GET /paras
  • GET /paras/auctions/current
  • GET /paras/crowdloans
  • GET /paras/leases/current
  • GET /paras/{paraId}/crowdloan-info
  • GET /paras/{paraId}/lease-info

transaction

  • POST /transaction
  • POST /transaction/dry-run
  • POST /transaction/fee-estmate
  • GET /transaction/material

How To Access Polkadot via Substrate Sidecar API

Step 1. To access the available Substrate Sidecar methods, use the following Ubiquity native access endpoint:

Network: Polkadot Mainnet
Request Type: POST / GET

https://svc.blockdaemon.com/polkadot/mainnet/native

Network: Polkadot Westend
Request Type: POST / GET

https://svc.blockdaemon.com/polkadot/westend/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Add a Substrate Sidecar method at the end of the query:

https://svc.blockdaemon.com/polkadot/mainnet/native/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request for Substrate Sidecar API

Here is a cURL example for using GET /blocks/head/header to get the header of the most recently finalized block in Polkadot Mainnet:

curl -X GET \
https://svc.blockdaemon.com/polkadot/mainnet/native/blocks/head/header \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "parentHash": "0xce2dacd2a92d2ae272786c9fcca3f7bd831ef0f87fca252442a0e698a3366490",
    "number": "11557833",
    "stateRoot": "0xec013a64ddfc05f4a1fcc84e2a15d6e158fbd88fce541b7b96ed40c3d4ba6c40",
    "extrinsicsRoot": "0x4ebf6e119dff512925598aade56145811aa09f459f816f8e77dc8b9c396de2ec",
    "digest": {
        "logs": [
            {
                "preRuntime": [
                    "0x42414245",
                    "0x01b90000002a257e10000000000a154a6d22a07fcbb4769a5bec0983edba50d356753f6f006a795dca69c8462230b43eafb92eb8ed56beb9b28e1f399f910913d46cc974877876f826f0f7310fca528c6f73ae6acba72094a01659796f47701145357add6db6dbe7978cded101"
                ]
            },
            {
                "seal": [
                    "0x42414245",
                    "0xfc0ffcf11176d71725bf8f14e0691185a0159a3d06ce59811c09305b0df0b37c1949883a28837403feb225229923d53bbca2c4dcf82b8251f2aca964beedb385"
                ]
            }
        ]
    }
}

Polygon

In this section you will find out which Polygon methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Polygon Mainnet

Supported Ethereum Methods

You can access Polygon via Ethereum API. Learn more: Ethereum API reference

How To Access Polygon via Ethereum API

Step 1. To access the available Ethereum methods, use the Ubiquity native access endpoint with http-rpc at the end:

Network: Polygon Mainnet
Request Type: POST

https://svc.blockdaemon.com/polygon/mainnet/native/http-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an Ethereum method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using eth_blockNumber to get the current block number in Polygon Mainnet:

curl -X \
POST https://svc.blockdaemon.com/polygon/mainnet/native/http-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x22105c3"
}

Supported Tendermint Methods

You can access Polygon via Tendermint RPC API. Learn more: Tendermint API reference

How To Access Polygon via Tendermint RPC API

Step 1. To access the available Tendermint methods, use the Ubiquity native access endpoint with tendermint-rpc at the end:

Network: Polygon Mainnet
Request Type: POST

https://svc.blockdaemon.com/polygon/mainnet/native/tendermint-rpc

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Tendermint method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using health to get a node heartbeat for Polygon Mainnet:

curl -X \
POST https://svc.blockdaemon.com/polygon/mainnet/native/tendermint-rpc \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "health", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": {}
}

How To Access Polygon via Tendermint REST API

Step 1. To access the available Tendermint methods, use the Ubiquity native access endpoint with tendermint-rest at the end:

Network: Polygon Mainnet
Request Type: GET

https://svc.blockdaemon.com/polygon/mainnet/native/tendermint-rest

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Tendermint method at the end of the query:

https://svc.blockdaemon.com/polygon/mainnet/native/tendermint-rest/YOUR_METHOD

Example Request

Here is a cURL example for using health to get a node heartbeat for Polygon Mainnet:

curl -X GET \
https://svc.blockdaemon.com/polygon/mainnet/native/tendermint-rest/health \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "id": 0,
    "result": {}
}

Solana

In this section you will find out which Solana methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Solana Mainnet
  • Solana Testnet

Supported Solana Methods

You can find Solana API documentation here: Solana API reference

The following methods are allowed in Ubiquity Native Access API:

How To Access Solana API

Step 1. To access the available Solana methods, use the following Ubiquity native access endpoint:

Network: Solana Mainnet
Request Type: POST

https://svc.blockdaemon.com/solana/mainnet/native

Network: Solana Testnet
Request Type: POST

https://svc.blockdaemon.com/solana/testnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Solana method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using getBlockHeight to get the current block height in Solana Mainnet:

curl -X POST \
https://svc.blockdaemon.com/solana/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "getBlockHeight", "params": []}'

The following is a typical response you will get:

{
    "jsonrpc": "2.0",
    "result": 131348841,
    "id": 1
}

Stellar

In this section you will find out which Stellar methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Stellar Mainnet

Supported Stellar Methods

You can find Stellar API documentation here: Stellar API reference

The following methods are allowed in Ubiquity Native Access API:

Ledgers

Transactions

Operations

Effects

Accounts

Offers

Trades

Assets

Claimable Balances

Liquitdity Pools

Aggregations

How To Access Stellar API

Step 1. To access the available Stellar methods, use the following Ubiquity native access endpoint:

Network: Stellar Mainnet
Request Type: GET / POST

https://svc.blockdaemon.com/stellar/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Stellar method at the end of the query:

https://svc.blockdaemon.com/stellar/mainnet/native/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request

Here is a cURL example for using ledgers to list all ledgers in Stellar Mainnet:

curl -X GET \
https://svc.blockdaemon.com/stellar/mainnet/native/ledgers \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "_links": {
        "self": {
            "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers?cursor=&limit=10&order=asc"
        },
        "next": {
            "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers?cursor=47244640256&limit=10&order=asc"
        },
        "prev": {
            "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers?cursor=8589934592&limit=10&order=desc"
        }
    },
    "_embedded": {
        "records": [
            {
                "_links": {
                    "self": {
                        "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers/2"
                    },
                    "transactions": {
                        "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers/2/transactions{?cursor,limit,order}",
                        "templated": true
                    },
                    "operations": {
                        "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers/2/operations{?cursor,limit,order}",
                        "templated": true
                    },
                    "payments": {
                        "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers/2/payments{?cursor,limit,order}",
                        "templated": true
                    },
                    "effects": {
                        "href": "https://ubiquity-fullnode-2-mainnet.stellar.bdnodes.net/ledgers/2/effects{?cursor,limit,order}",
                        "templated": true
                    }
                },
                "id": "fe0f6bea5f341344fdb5bc6fc4ad719dd63071d9203e9a1e7f17c68ea1ecebde",
                "paging_token": "8589934592",
                "hash": "fe0f6bea5f341344fdb5bc6fc4ad719dd63071d9203e9a1e7f17c68ea1ecebde",
                "prev_hash": "39c2a3cd4141b2853e70d84601faa44744660334b48f3228e0309342e3f4eb48",
                "sequence": 2,
                "successful_transaction_count": 0,
                "failed_transaction_count": 0,
                "operation_count": 0,
                "tx_set_operation_count": 0,
                "closed_at": "2015-09-30T16:46:54Z",
                "total_coins": "100000000000.0000000",
                "fee_pool": "0.0000000",
                "base_fee_in_stroops": 100,
                "base_reserve_in_stroops": 100000000,
                "max_tx_set_size": 500,
                "protocol_version": 1,
                "header_xdr": "AAAAATnCo81BQbKFPnDYRgH6pEdEZgM0tI8yKOAwk0Lj9OtIzUjr/foF3Zu1Snl7gIUXUGqhoUJG2tzUKbNoPAsFhpEAAAAAVgwR/gAAAAIAAAAIAAAAAQAAAAEAAAAIAAAAAwAAAfQAAAAA3z9hmASpL9tAVxktxD3XSOp3itxSvEmM6AUkwBS4ERmR2QgH0N3bkOnEnemuBV73KfTL2fMONrNcU1pXRKIkMgAAAAIN4Lazp2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAX14QAAAAH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
            },
            { ...more items... }
        ]
    }
}

Tezos

In this section you will find out which Tezos methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • Tezos Mainnet

Supported Tezos Methods

You can find Tezos API documentation here: Tezos API reference

The following methods are allowed in Ubiquity Native Access API:

How To Access Tezos API

Step 1. To access the available Tezos methods, use the following Ubiquity native access endpoint:

Network: Tezos Mainnet
Request Type: GET / POST

https://svc.blockdaemon.com/tezos/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify a Tezos method at the end of the query:

https://svc.blockdaemon.com/tezos/mainnet/native/YOUR_METHOD

Step 4. For POST requests, specify the data required by the method in the request body.

Example Request

Here is a cURL example for using /network/stat to get the network statistics for Tezos Mainnet:

curl -X GET \
https://svc.blockdaemon.com/tezos/mainnet/native/network/stat \
-H 'Authorization: Bearer YOUR_API_KEY'

The following is a typical response you will get:

{
    "total_sent": "362092994390",
    "total_recv": "472560797348",
    "current_inflow": 342122,
    "current_outflow": 211765
}

XRP

In this section you will find out which XRP methods are whitelisted in Ubiquity and how to access them:

The following networks are supported:

  • XRP Mainnet

Supported XRP Methods

You can find XRP API documentation here: XRP API reference

The following methods are allowed in Ubiquity Native Access API:

Account Methods

Ledger Methods

Transactions Methods

Path and Order Book Methods

Payment Channel Methods

Subscription Methods

Server Info Methods

Clio Server Methods

Utility Methods

How To Access XRP API

Step 1. To access the available XRP methods, use the following Ubiquity native access endpoint:

Network: XRP Mainnet
Request Type: POST

https://svc.blockdaemon.com/xrp/mainnet/native

Step 2. You should authorize your request. Learn more: Authentication Guide

Step 3. Specify an XRP method in the request body:

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "YOUR_METHOD",
    "params": []
}

Example Request

Here is a cURL example for using ledger_current to get the unique identifier of the current in-progress ledger in XRP Mainnet:

curl -X POST \
https://svc.blockdaemon.com/xrp/mainnet/native \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc": "2.0", "id": 1, "method": "ledger_current", "params": []}'

The following is a typical response you will get:

{
    "result": {
        "ledger_current_index": 73876024,
        "status": "success"
    }
}

We don't support Internet Explorer

Please use Chrome, Safari, Firefox, or Edge to view this site.