Skip to content

GraphQL Overview

Download GraphQL schema
index.graphql

Queries

Overview

balance

(...args)
QueryBalanceConnection!,non-null

Returns the balances for a given account, chain, and module combination.

This query calculates and returns the user's balance for each specified combination of account, chain ID, and module. For example, it can return how much balance the account k:9492...5c17 holds on chain 1 within the coin module.

Arguments

accountName
String

The full account name to retrieve balances for.

chainIds
[String!],non-null

A list of chain IDs to include in the balance retrieval. Example: ["0", "1"]

module
String

The name of the module that issued the token. Example: "coin"

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of balance records to return when paginating forward.

last
Int

Maximum number of balance records to return when paginating backward.

Return type

QueryBalanceConnection!
edges
[QueryBalanceConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query balance(
  $accountName: String
  $chainIds: [String!]
  $module: String
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  balance(
    accountName: $accountName
    chainIds: $chainIds
    module: $module
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        accountName 
        module 
        chainId 
        balance 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "accountName": "Example String",
  "chainIds": [
    "Example String"
  ],
  "module": "Example String",
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "accountName": "Example String",
          "module": "Example String",
          "chainId": "Example String",
          "balance": "Example String"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

block

(hash)
Block

Retrieve detailed information about a specific block using its unique hash.

Every block in the Kadena blockchain is identified by a cryptographic hash — a unique fingerprint generated from its contents. This query allows you to look up a block directly by that hash, returning all available details about it, such as its height, creation time, transactions, miner, and more.

This is especially useful when you already know the block’s hash (for example, from a transaction receipt or an event log) and want to quickly inspect or verify that block’s contents without scanning the entire chain.

Arguments

hash
String!,non-nullrequired

The unique cryptographic hash (identifier) of the block to retrieve.

Return type

Block
id
ID!,non-null

Globally unique identifier for this block node.

hash
String!,non-null

The cryptographic hash of the block. This serves as its unique identifier within the blockchain.

chainId
BigInt!,non-null

The specific chain where this block was mined. Kadena is a multi-chain system, and each block belongs to exactly one chain.

creationTime
DateTime!,non-null

The timestamp when this block was created and added to the chain.

difficulty
BigInt!,non-null

The network difficulty at the time the block was mined. Higher difficulty reflects the amount of computational work required to produce a valid block.

epoch
DateTime!,non-null

The epoch timestamp marking when the difficulty was last adjusted. Kadena targets ~30 seconds per block, and the difficulty is recalibrated periodically to maintain that target.

flags
Decimal!,non-null

Consensus flags used internally by the protocol.

height
BigInt!,non-null

The height (block number) of this block within its chain. The genesis block is height 0, and each subsequent block increments by 1.

nonce
Decimal!,non-null

A nonce value used in the proof-of-work process. Miners vary this value to discover a hash below the target threshold.

payloadHash
String!,non-null

The hash of the payload data contained within the block. This ensures the integrity of the transactions and other included data.

weight
String!,non-null

The cumulative weight of the chain up to and including this block. Weight increases with each mined block and helps determine the canonical chain.

target
String!,non-null

The target hash threshold that the block’s proof-of-work hash must fall below. This value adjusts with difficulty to regulate block production time.

coinbase
String!,non-null

The coinbase transaction data. This transaction rewards the miner and may include information about block rewards or other protocol-defined payouts.

neighbors
[BlockNeighbor!]!,non-null

The neighboring blocks that reference this block as a parent. These neighbors are essential in Kadena’s braided multi-chain architecture.

powHash
String!,non-null

The proof-of-work hash of the block. This is the result of hashing the block header with the nonce and must satisfy the target condition.

canonical
Boolean!,non-null

Indicates whether this block is part of the canonical chain. Non-canonical blocks may occur during temporary forks or reorganizations.

parent
Block

The parent block directly preceding this one in the chain. Together with the hash, this forms the cryptographic link that secures the chain.

totalGasUsedInKda
Decimal!,non-null

The total amount of gas used by all transactions in this block, expressed in KDA.

events
BlockEventsConnection!,non-null

Paginated list of events emitted by transactions within this block.

afterbeforefirstlast
minerAccount
FungibleChainAccount!,non-null

The account that mined this block and received the coinbase reward.

transactions
BlockTransactionsConnection!,non-null

Paginated list of transactions included in this block.

afterbeforefirstlast
Query sample
query block($hash: String!) {
  block(hash: $hash) {
    id 
    hash 
    chainId 
    creationTime 
    difficulty 
    epoch 
    flags 
    height 
    nonce 
    payloadHash 
    weight 
    target 
    coinbase 
    neighbors {
      __typename
      # ...BlockNeighborFragment
    }
    powHash 
    canonical 
    parent {
      __typename
      # ...BlockFragment
    }
    totalGasUsedInKda 
    events(
      # Arguments Here
    ) {
      __typename
      # ...BlockEventsConnectionFragment
    }
    minerAccount {
      __typename
      # ...FungibleChainAccountFragment
    }
    transactions(
      # Arguments Here
    ) {
      __typename
      # ...BlockTransactionsConnectionFragment
    }
  }
}
Variables
{
  "hash": "Example String"
}
Response sample
{
  "data": {
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "hash": "Example String",
    "chainId": "Example Custom Scalar",
    "creationTime": "Example Custom Scalar",
    "difficulty": "Example Custom Scalar",
    "epoch": "Example Custom Scalar",
    "flags": "Example Custom Scalar",
    "height": "Example Custom Scalar",
    "nonce": "Example Custom Scalar",
    "payloadHash": "Example String",
    "weight": "Example String",
    "target": "Example String",
    "coinbase": "Example String",
    "neighbors": [
      {
        "__typename": "BlockNeighbor"
      }
    ],
    "powHash": "Example String",
    "canonical": true,
    "parent": {
      "__typename": "Block"
    },
    "totalGasUsedInKda": "Example Custom Scalar",
    "events": {
      "__typename": "BlockEventsConnection"
    },
    "minerAccount": {
      "__typename": "FungibleChainAccount"
    },
    "transactions": {
      "__typename": "BlockTransactionsConnection"
    }
  }
}

blocksFromDepth

(...args)
QueryBlocksFromDepthConnection

Retrieves blocks based on their depth in the Kadena blockchain.

In Kadena, each new block extends the chain by one unit, and the term depth refers to how far a block is from the current chain tip (the most recent block).

  • A block with a depth of 0 is the latest block (the chain head).
  • A block with a depth of 1 is one block behind the tip, and so on.

Because new blocks can occasionally be reorganized near the tip, specifying a minimumDepth helps ensure that only blocks that are deep enough — and therefore finalized and stable — are returned. For example, a minimumDepth of 20 means only blocks that are at least 20 blocks behind the current tip will be included in the results, reducing the chance of including blocks that might later be replaced due to a chain reorganization.

Use this query to fetch finalized blocks across one or more chains.

Arguments

chainIds
[String!],non-null

The chain IDs to retrieve blocks from.

minimumDepth
Int!,non-nullrequired

The minimum depth of the blocks to retrieve. Blocks closer to the tip than this depth will be excluded.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of balance records to return when paginating forward.

last
Int

Maximum number of balance records to return when paginating backward.

Return type

QueryBlocksFromDepthConnection
edges
[QueryBlocksFromDepthConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query blocksFromDepth(
  $chainIds: [String!]
  $minimumDepth: Int!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  blocksFromDepth(
    chainIds: $chainIds
    minimumDepth: $minimumDepth
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        hash 
        chainId 
        creationTime 
        difficulty 
        epoch 
        flags 
        height 
        nonce 
        payloadHash 
        weight 
        target 
        coinbase 
        neighbors {
          __typename
          # ...BlockNeighborFragment
        }
        powHash 
        canonical 
        parent {
          __typename
          # ...BlockFragment
        }
        totalGasUsedInKda 
        events(
          # Arguments Here
        ) {
          __typename
          # ...BlockEventsConnectionFragment
        }
        minerAccount {
          __typename
          # ...FungibleChainAccountFragment
        }
        transactions(
          # Arguments Here
        ) {
          __typename
          # ...BlockTransactionsConnectionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "chainIds": [
    "Example String"
  ],
  "minimumDepth": 40,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "hash": "Example String",
          "chainId": "Example Custom Scalar",
          "creationTime": "Example Custom Scalar",
          "difficulty": "Example Custom Scalar",
          "epoch": "Example Custom Scalar",
          "flags": "Example Custom Scalar",
          "height": "Example Custom Scalar",
          "nonce": "Example Custom Scalar",
          "payloadHash": "Example String",
          "weight": "Example String",
          "target": "Example String",
          "coinbase": "Example String",
          "neighbors": [
            {
              "__typename": "BlockNeighbor"
            }
          ],
          "powHash": "Example String",
          "canonical": true,
          "parent": {
            "__typename": "Block"
          },
          "totalGasUsedInKda": "Example Custom Scalar",
          "events": {
            "__typename": "BlockEventsConnection"
          },
          "minerAccount": {
            "__typename": "FungibleChainAccount"
          },
          "transactions": {
            "__typename": "BlockTransactionsConnection"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

blocksFromHeight

(...args)
QueryBlocksFromHeightConnection!,non-null

Retrieve blocks from one or more chains based on their block height range.

In Kadena, height represents a block’s sequential position within its chain, starting at 0 for the genesis block and increasing by 1 for each new block. This query lets you fetch blocks by specifying a starting height (startHeight) and, optionally, an ending height (endHeight). It is particularly useful when you want to retrieve a continuous range of blocks — for example, when backfilling data, syncing from a specific point in the chain, or analyzing block activity over a known range.

If endHeight is omitted, the query returns all blocks from the starting height up to the current chain tip.

Arguments

chainIds
[String!],non-null

The chain IDs to retrieve blocks from. Kadena runs multiple braided chains in parallel — specify one or more chain IDs here.

endHeight
Int

The inclusive upper bound of the height range. If omitted, results will include all blocks from startHeight to the current tip.

startHeight
Int!,non-nullrequired

The inclusive lower bound of the height range. Blocks with a height below this value will be excluded.

after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of records to return when paginating forward.

last
Int

Maximum number of records to return when paginating backward.

Return type

QueryBlocksFromHeightConnection!
edges
[QueryBlocksFromHeightConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query blocksFromHeight(
  $chainIds: [String!]
  $endHeight: Int
  $startHeight: Int!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  blocksFromHeight(
    chainIds: $chainIds
    endHeight: $endHeight
    startHeight: $startHeight
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        hash 
        chainId 
        creationTime 
        difficulty 
        epoch 
        flags 
        height 
        nonce 
        payloadHash 
        weight 
        target 
        coinbase 
        neighbors {
          __typename
          # ...BlockNeighborFragment
        }
        powHash 
        canonical 
        parent {
          __typename
          # ...BlockFragment
        }
        totalGasUsedInKda 
        events(
          # Arguments Here
        ) {
          __typename
          # ...BlockEventsConnectionFragment
        }
        minerAccount {
          __typename
          # ...FungibleChainAccountFragment
        }
        transactions(
          # Arguments Here
        ) {
          __typename
          # ...BlockTransactionsConnectionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "chainIds": [
    "Example String"
  ],
  "endHeight": 40,
  "startHeight": 40,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "hash": "Example String",
          "chainId": "Example Custom Scalar",
          "creationTime": "Example Custom Scalar",
          "difficulty": "Example Custom Scalar",
          "epoch": "Example Custom Scalar",
          "flags": "Example Custom Scalar",
          "height": "Example Custom Scalar",
          "nonce": "Example Custom Scalar",
          "payloadHash": "Example String",
          "weight": "Example String",
          "target": "Example String",
          "coinbase": "Example String",
          "neighbors": [
            {
              "__typename": "BlockNeighbor"
            }
          ],
          "powHash": "Example String",
          "canonical": true,
          "parent": {
            "__typename": "Block"
          },
          "totalGasUsedInKda": "Example Custom Scalar",
          "events": {
            "__typename": "BlockEventsConnection"
          },
          "minerAccount": {
            "__typename": "FungibleChainAccount"
          },
          "transactions": {
            "__typename": "BlockTransactionsConnection"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

completedBlockHeights

(...args)
QueryCompletedBlockHeightsConnection!,non-null

Retrieve a list of completed block heights across one or more chains, starting from a given point.

In Kadena’s braided multi-chain architecture, a block height is considered completed only when all chains have successfully produced a block at that height. Since each chain progresses independently, some chains may temporarily lag behind others. This query ensures that only globally finalized heights — where every specified chain has reached that block height — are returned.

This is particularly useful for building indexers, explorers, and analytics tools that require consistent cross-chain data. You can specify how many completed heights to return with heightCount.

Arguments

chainIds
[String!],non-null

The chain IDs to include when checking for completed heights. Only heights where all of these chains have produced a block will be returned.

completedHeights
Boolean
Default:true

Whether to include only completed heights. Defaults to true. If set to false, the query may include heights that are not yet completed across all chains.

heightCount
Int
Default:3

The maximum number of sequential completed heights to return per query. Results are always returned without gaps, starting from the most recent completed height and moving backward if no pagination arguments are provided.

Examples:

  • If completed heights are 101, 102, 103, 104, and 105, and you set heightCount: 3 without pagination, the query returns the 3 most recent completed heights: 105, 104, 103.
  • If you set heightCount: 10 in the same scenario, the query still returns only the 5 available heights: 105, 104, 103, 102, 101.
after
String

Cursor to start paginating after a specific result. Used for forward pagination.

before
String

Cursor to start paginating before a specific result. Used for backward pagination.

first
Int

Maximum number of results to return when paginating forward.

last
Int

Maximum number of results to return when paginating backward.

Return type

QueryCompletedBlockHeightsConnection!
edges
[QueryCompletedBlockHeightsConnectionEdge]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query completedBlockHeights(
  $chainIds: [String!]
  $completedHeights: Boolean
  $heightCount: Int
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  completedBlockHeights(
    chainIds: $chainIds
    completedHeights: $completedHeights
    heightCount: $heightCount
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        hash 
        chainId 
        creationTime 
        difficulty 
        epoch 
        flags 
        height 
        nonce 
        payloadHash 
        weight 
        target 
        coinbase 
        neighbors {
          __typename
          # ...BlockNeighborFragment
        }
        powHash 
        canonical 
        parent {
          __typename
          # ...BlockFragment
        }
        totalGasUsedInKda 
        events(
          # Arguments Here
        ) {
          __typename
          # ...BlockEventsConnectionFragment
        }
        minerAccount {
          __typename
          # ...FungibleChainAccountFragment
        }
        transactions(
          # Arguments Here
        ) {
          __typename
          # ...BlockTransactionsConnectionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "chainIds": [
    "Example String"
  ],
  "completedHeights": true,
  "heightCount": 40,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "hash": "Example String",
          "chainId": "Example Custom Scalar",
          "creationTime": "Example Custom Scalar",
          "difficulty": "Example Custom Scalar",
          "epoch": "Example Custom Scalar",
          "flags": "Example Custom Scalar",
          "height": "Example Custom Scalar",
          "nonce": "Example Custom Scalar",
          "payloadHash": "Example String",
          "weight": "Example String",
          "target": "Example String",
          "coinbase": "Example String",
          "neighbors": [
            {
              "__typename": "BlockNeighbor"
            }
          ],
          "powHash": "Example String",
          "canonical": true,
          "parent": {
            "__typename": "Block"
          },
          "totalGasUsedInKda": "Example Custom Scalar",
          "events": {
            "__typename": "BlockEventsConnection"
          },
          "minerAccount": {
            "__typename": "FungibleChainAccount"
          },
          "transactions": {
            "__typename": "BlockTransactionsConnection"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

Subscriptions

Overview

Directives

Overview

Objects

Overview

Interfaces

Overview

Unions

Overview

Enums

Overview

Inputs

Overview

Scalars

Overview