GraphQL Overview

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.

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, sigs

• stringified-command: A JSON-stringified command. Required: cmd (optional: sigs)

• full-command: A complete command object. Required: payload, meta, signers

• partial-command: A partially defined command. Required: payload and either meta or signers (optional: chainId if signers is provided without meta)

• payload: Only the payload of a command. Required: payload, chainId

• code: 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
  }
}

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.

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.