- lastBlockHeight
Retrieve details of a specific fungible account on a specific chain.
In Kadena’s multi-chain architecture, an account can exist on multiple chains simultaneously, each maintaining
its own balance and transaction history. This query lets you retrieve the state of a single FungibleChainAccount
by specifying the account name, the chain ID, and the fungible token module (default: coin).
It’s particularly useful when you need precise, chain-level information — such as a user’s balance or transfer activity — without aggregating data across all chains.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The chain ID where the account exists. Kadena runs multiple braided chains, and balances are tracked separately on each.
The name of the fungible token module (e.g., coin) associated with the account.
Defaults to "coin" if not specified.
Return type
FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccount(
$accountName: String!
$chainId: String!
$fungibleName: String
) {
fungibleChainAccount(
accountName: $accountName
chainId: $chainId
fungibleName: $fungibleName
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "chainId": "Example String", "fungibleName": "Example String" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } }
Retrieve fungible account details across multiple chains.
In Kadena’s multi-chain architecture, an account can exist on several chains simultaneously — each maintaining its own
balance, guard, and activity history. This query allows you to retrieve all FungibleChainAccount objects for a given
account name and fungible token (default: coin) across one or more specified chains in a single request.
It’s especially useful when you want a comprehensive view of how an account is distributed across multiple chains, including balances and per-chain transaction or transfer histories.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The list of chain IDs where the account exists.
You can specify one or more chains to retrieve FungibleChainAccount details for each.
The name of the fungible token module associated with the account (e.g., coin).
Defaults to "coin" if not specified.
Return type
[FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccounts(
$accountName: String!
$chainIds: [String!]
$fungibleName: String
) {
fungibleChainAccounts(
accountName: $accountName
chainIds: $chainIds
fungibleName: $fungibleName
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "chainIds": [ "Example String" ], "fungibleName": "Example String" }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } ] }
Retrieve all fungible chain accounts associated with a given public key on a specific chain.
In Kadena, a single public key can control multiple accounts on the same chain — for example,
accounts created by different contracts or modules. This query returns all FungibleChainAccount
objects linked to the provided public key for a specified fungible token (default: coin) on the given chain.
It’s especially useful when you want to discover all accounts controlled by a user key on a particular chain, including their balances, guards, and per-chain transaction history.
Arguments
The ID of the chain to search on. Kadena runs multiple braided chains — specify the one where the accounts exist.
The name of the fungible token module to filter by (e.g., coin for the native KDA token).
Defaults to "coin" if not specified.
The public key used to control the account(s).
Example: "abcdef1234567890...".
Return type
[FungibleGlobally unique identifier for this chain account node.
The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
The current balance of this account on the specified chain for the given fungible token.
The chain ID where this account exists.
The name of the fungible token module associated with this account (e.g., coin).
The guard that defines the account’s security conditions. A guard determines who must sign transactions in order to spend from this account.
Paginated list of transactions involving this account on this chain. Transactions represent operations such as transfers, contract calls, or other state changes.
Paginated list of token transfers into or out of this account on this chain. Transfers are a subset of events focused specifically on balance movements.
query fungibleChainAccountsByPublicKey(
$chainId: String!
$fungibleName: String
$publicKey: String!
) {
fungibleChainAccountsByPublicKey(
chainId: $chainId
fungibleName: $fungibleName
publicKey: $publicKey
) {
id
accountName
balance
chainId
fungibleName
guard {
__typename
# ...IGuardFragment
}
transactions(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...FungibleChainAccountTransfersConnectionFragment
}
}
}{ "chainId": "Example String", "fungibleName": "Example String", "publicKey": "Example String" }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "accountName": "Example String", "balance": 40, "chainId": "Example String", "fungibleName": "Example String", "guard": { "__typename": "IGuard" }, "transactions": { "__typename": "FungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "FungibleChainAccountTransfersConnection" } } ] }
Estimate the gas limit required to execute one or more transactions on the Kadena blockchain.
This query accepts one or more JSON-encoded transaction inputs and analyzes them to calculate the expected gas usage. It automatically infers the transaction type based on the fields provided and returns the estimated gas limit for each input. If any transaction is invalid or cannot be parsed, the query will throw an error.
Supported input types and required fields:
full-transaction: A fully signed transaction object. Required:cmd,hash,sigsstringified-command: A JSON-stringified command. Required:cmd(optional:sigs)full-command: A complete command object. Required:payload,meta,signerspartial-command: A partially defined command. Required:payloadand eithermetaorsigners(optional:chainIdifsignersis provided withoutmeta)payload: Only the payload of a command. Required:payload,chainIdcode: Pact execution code. Required:code,chainId
All input types optionally accept networkId to override the default network configured in the environment.
query {
gasLimitEstimate(
input: [
"{
\"code\": \"(coin.details \\\"k:1234\\\")\",
\"chainId\": \"3\"
}"
]
) {
amount
inputType
}
}
Arguments
One or more JSON-encoded transaction inputs to estimate gas for. Each entry must follow one of the supported input type structures listed above.
Return type
[GasThe estimated gas limit required to execute the transaction.
The detected input type (e.g., code, payload, full-transaction, etc.).
The normalized JSON representation of the transaction used for estimation.
Whether a pre-execution (preflight) simulation was used during estimation.
Whether signature verification was performed as part of the estimation.
query gasLimitEstimate($input: [String!]!) {
gasLimitEstimate(input: $input) {
amount
inputType
transaction
usedPreflight
usedSignatureVerification
}
}{ "input": [ "Example String" ] }
{ "data": [ { "amount": 40, "inputType": "Example String", "transaction": "Example String", "usedPreflight": true, "usedSignatureVerification": true } ] }
Retrieve general information about this GraphQL API endpoint. It is commonly used to check how far back the indexer’s data goes and to verify the API version your application is interacting with.
Return type
Graphquery graphConfiguration {
graphConfiguration {
minimumBlockHeight
version
}
}{ "data": { "minimumBlockHeight": "Example Custom Scalar", "version": "Example String" } }
Get the height of the block with the highest height.
Return type
BigThe BigInt scalar type represents non-fractional signed whole numeric values.
query lastBlockHeight {
lastBlockHeight
}{ "data": "Example Custom Scalar" }
Retrieve comprehensive information about the Kadena network.
This query returns a NetworkInfo object containing key metrics and configuration details
about the current state of the network.
Developers typically use this query to monitor network health, verify node synchronization, analyze performance metrics, or display high-level blockchain data in explorers and dashboards.
Return type
NetworkThe version of this GraphQL API. Useful to verify compatibility between the client and API.
The current total number of coins in circulation on the network.
The current aggregate hash rate of the Kadena network. Indicates the total mining power securing the network.
The host address or domain of the network node serving this API.
The unique identifier of the network (e.g., mainnet01, testnet04).
The cumulative difficulty of all blocks mined so far. A higher value reflects the total work securing the chain.
The total number of transactions that have been processed across the network.
The current delay (in blocks) between the latest mined block and the block processed by the node. Useful for monitoring node synchronization status.
The list of chain IDs that make up the Kadena network. Kadena operates multiple braided chains in parallel.
The total number of chains in the network.
The genesis block height for each chain in the network. Provides insight into the starting point of each chain’s history.
The version of the node software package running this endpoint.
The service start date and time of the current node. Useful for tracking uptime and deployment history.
The latest block height known by the node’s behavior monitor. Can be used to assess node synchronization and chain progress.
Transaction counters and statistics broken down by chain. Useful for analyzing per-chain activity levels and throughput.
query networkInfo {
networkInfo {
apiVersion
coinsInCirculation
networkHashRate
networkHost
networkId
totalDifficulty
transactionCount
nodeBlockDelay
nodeChains
numberOfChains
genesisHeights {
__typename
# ...GenesisHeightFragment
}
nodePackageVersion
nodeServiceDate
nodeLatestBehaviorHeight
countersOfEachChain {
__typename
# ...CountersOfEachChainFragment
}
}
}{ "data": { "apiVersion": "Example String", "coinsInCirculation": 40, "networkHashRate": 40, "networkHost": "Example String", "networkId": "Example String", "totalDifficulty": 40, "transactionCount": 40, "nodeBlockDelay": 40, "nodeChains": [ "Example String" ], "numberOfChains": 40, "genesisHeights": [ { "__typename": "GenesisHeight" } ], "nodePackageVersion": "Example String", "nodeServiceDate": "Example Custom Scalar", "nodeLatestBehaviorHeight": 40, "countersOfEachChain": [ { "__typename": "CountersOfEachChain" } ] } }
Retrieve a single object in the graph by its globally unique identifier.
All major entities in this API implement the Node interface, which ensures that each one
has a unique id field. This query allows you to fetch any of those entities directly
using that global ID, regardless of its specific type (e.g., Block, Transaction, FungibleAccount).
Arguments
The globally unique identifier (id) of the object to retrieve.
Return type
NodeA globally unique identifier for the object.
query node($id: ID!) {
node(id: $id) {
id
}
}{ "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" }
{ "data": { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" } }
Retrieve multiple objects in the graph by their globally unique identifiers.
Like the node query, this query returns any entities that implement the Node interface,
but allows you to request several objects in a single call by passing a list of IDs.
It’s useful when resolving multiple references at once — for example, when reconstructing
relationships between entities or populating a list by ID.
Arguments
A list of globally unique identifiers (id) of the objects to retrieve.
Return type
[Node]!A globally unique identifier for the object.
query nodes($ids: [ID!]!) {
nodes(ids: $ids) {
id
}
}{ "ids": [ "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" ] }
{ "data": [ { "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4" } ] }
Retrieve details of a specific non-fungible account by its name.
A non-fungible account represents the ownership and activity of unique tokens (NFTs) on the Kadena blockchain. Unlike fungible accounts that track divisible token balances, non-fungible accounts hold individual, distinct tokens and their associated metadata.
This query lets you look up a specific account and retrieve information such as its NFT balances, per-chain details, and historical transaction and transfer activity. It is commonly used in NFT explorers, wallets, or analytics tools to inspect an account’s non-fungible holdings and interactions.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
Return type
NonThe full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).
Per-chain breakdown of this non-fungible account. Since Kadena operates multiple braided chains, NFT balances and activity are tracked separately on each chain.
Globally unique identifier for this non-fungible account node.
A list of non-fungible token balances held by this account across all chains. Each balance entry includes token identifiers, metadata, and ownership details.
Paginated list of transactions involving this account. Note: Custom token-related transactions are not included. Transactions here represent operations such as NFT minting, transfers, or contract interactions related to NFTs.
Paginated list of NFT transfers associated with this account. Transfers represent movements of non-fungible tokens into or out of this account.
query nonFungibleAccount($accountName: String!) {
nonFungibleAccount(accountName: $accountName) {
accountName
chainAccounts {
__typename
# ...NonFungibleChainAccountFragment
}
id
nonFungibleTokenBalances {
__typename
# ...NonFungibleTokenBalanceFragment
}
transactions(
# Arguments Here
) {
__typename
# ...NonFungibleAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...NonFungibleAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String" }
{ "data": { "accountName": "Example String", "chainAccounts": [ { "__typename": "NonFungibleChainAccount" } ], "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "nonFungibleTokenBalances": [ { "__typename": "NonFungibleTokenBalance" } ], "transactions": { "__typename": "NonFungibleAccountTransactionsConnection" }, "transfers": { "__typename": "NonFungibleAccountTransfersConnection" } } }
Retrieve details of a specific non-fungible account on a specific chain.
This query returns a NonFungibleChainAccount, which represents an account’s NFT holdings and activity
restricted to a single chain within the Kadena network. Because Kadena operates as a multi-chain blockchain,
NFT balances, transactions, and transfers are tracked separately on each chain.
Use this query when you need precise, chain-level data about a particular account — for example, when building an NFT explorer or wallet feature that shows a user’s holdings and interactions on a specific chain.
Arguments
The full name of the account to retrieve.
Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.
The ID of the chain where the account exists. Kadena runs multiple braided chains, and NFT data is tracked separately on each.
Return type
NonThe full name of the account (e.g., k:abcdef123456... for a user account
or free.my-contract for a contract account).
The chain ID where this non-fungible account exists.
Globally unique identifier for this chain-scoped NFT account node.
The list of NFT balances held by this account on this chain. Each entry typically includes the token identifier(s), quantity/ownership info, and associated metadata for that token/collection.
Paginated list of NFT-related transactions involving this account on this chain. Transactions can include mints, transfers, or contract interactions that affect NFT state.
Paginated list of NFT transfers into or out of this account on this chain. Transfers are a subset of transactions focused specifically on movements of NFTs.
query nonFungibleChainAccount($accountName: String!, $chainId: String!) {
nonFungibleChainAccount(accountName: $accountName, chainId: $chainId) {
accountName
chainId
id
nonFungibleTokenBalances {
__typename
# ...NonFungibleTokenBalanceFragment
}
transactions(
# Arguments Here
) {
__typename
# ...NonFungibleChainAccountTransactionsConnectionFragment
}
transfers(
# Arguments Here
) {
__typename
# ...NonFungibleChainAccountTransfersConnectionFragment
}
}
}{ "accountName": "Example String", "chainId": "Example String" }
{ "data": { "accountName": "Example String", "chainId": "Example String", "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4", "nonFungibleTokenBalances": [ { "__typename": "NonFungibleTokenBalance" } ], "transactions": { "__typename": "NonFungibleChainAccountTransactionsConnection" }, "transfers": { "__typename": "NonFungibleChainAccountTransfersConnection" } } }