GraphQL Overview

Get the height of the block with the highest height.

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.

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

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.

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.

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.

Execute arbitrary Pact code via a local call without requiring gas estimation or signature verification.

The pactQuery query allows you to run read-only Pact code directly against the Kadena blockchain, such as arithmetic expressions or contract read functions (e.g., (coin.get-details "<account>")). It does not create a transaction or modify chain state — it simply executes the code locally and returns the result.

This is ideal for use cases like:

• Retrieving token or account details without submitting a transaction.
• Running lightweight Pact expressions or view functions.
• Building dashboards or explorers that query contract state in real time.

Multiple queries can be sent in a single request by providing an array of PactQuery objects.

Retrieve a specific transaction by its request key, with optional additional filters.

While a requestKey uniquely identifies a transaction at the Pact level, the same request key can appear in multiple blocks due to chain reorganization or orphaned blocks. Because of this, retrieving a transaction by requestKey alone may return more than one match over the chain’s history.

To disambiguate results, you can provide the blockHash parameter.

• A specific requestKey combined with a blockHash will always return at most one transaction, since that pair is unique.
• Among those combinations, only one transaction will belong to a canonical block (i.e., part of the main chain).
• All other matches (with the same requestKey but different blockHash values) represent transactions included in orphaned blocks — blocks that were mined but later discarded due to chain reorganization.

The minimumDepth parameter can also be used to limit results to transactions in blocks that are at least a certain depth from the chain tip, helping ensure finality.

This query is typically used when you need to verify the canonical inclusion of a transaction or inspect all occurrences of a given request key across the chain’s history.

Retrieve a paginated list of transactions with flexible filtering options.

This query allows you to search and explore transactions on the Kadena blockchain based on a wide range of parameters — including account involvement, block location, chain, request key, height range, and coinbase status. It is commonly used by block explorers, wallets, and analytics tools to inspect on-chain activity and trace transaction history.

You can combine multiple filters to refine results. For example:

• Filter by accountName to find transactions sent from or received by a specific account.
• Use blockHash to retrieve all transactions included in a particular block.
• Combine chainId, minHeight, and maxHeight to query transactions over a block range on a specific chain.
• Provide a requestKey to search for a particular transaction.
• Set isCoinbase to true to return only mining reward transactions.
• Use minimumDepth to ensure results include only transactions in finalized blocks.

Retrieve a paginated list of transactions associated with a specific public key.

This query returns all transactions that involve accounts controlled by the given publicKey. Because a single public key can control multiple accounts — including accounts on different chains or created by contracts — this query is a convenient way to fetch all related transactions without needing to know each account name individually.

It is commonly used by wallets, explorers, and analytics tools to display a user’s complete on-chain activity, track transactions linked to a particular key, or audit key usage across the network.

Retrieve a paginated list of transactions that executed a specific Pact code.

This query allows you to search for transactions based on the exact Pact code they executed. It’s particularly useful when you want to trace all interactions with a specific contract function, audit how and when a certain piece of code was used on-chain, or analyze usage patterns of a given module.

Because the match is performed on the full Pact code string, results will only include transactions where the executed code exactly matches the provided pactCode. This query is commonly used by block explorers, indexers, and analytics tools to track contract usage and behavior over time.