Skip to content
/
transactions

GraphQL Overview

Download GraphQL schema
index.graphql

Queries

Overview

nodes

(ids)
[Node]!,non-null

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

ids
[ID!]!,non-nullrequired

A list of globally unique identifiers (id) of the objects to retrieve.

Return type

[Node]!
id
ID!,non-null

A globally unique identifier for the object.

Query sample
query nodes($ids: [ID!]!) {
  nodes(ids: $ids) {
    id 
  }
}
Variables
{
  "ids": [
    "9cfb1c81-4c79-452f-b1f5-8ee6571276b4"
  ]
}
Response sample
{
  "data": [
    {
      "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4"
    }
  ]
}

nonFungibleAccount

(accountName)
NonFungibleAccount

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

accountName
String!,non-nullrequired

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

NonFungibleAccount
accountName
String!,non-null

The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).

chainAccounts
[NonFungibleChainAccount!]!,non-null

Per-chain breakdown of this non-fungible account. Since Kadena operates multiple braided chains, NFT balances and activity are tracked separately on each chain.

id
ID!,non-null

Globally unique identifier for this non-fungible account node.

nonFungibleTokenBalances
[NonFungibleTokenBalance!]!,non-null

A list of non-fungible token balances held by this account across all chains. Each balance entry includes token identifiers, metadata, and ownership details.

transactions
NonFungibleAccountTransactionsConnection!,non-null

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.

afterbeforefirstlast
transfers
NonFungibleAccountTransfersConnection!,non-null

Paginated list of NFT transfers associated with this account. Transfers represent movements of non-fungible tokens into or out of this account.

afterbeforefirstlast
Query sample
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
    }
  }
}
Variables
{
  "accountName": "Example String"
}
Response sample
{
  "data": {
    "accountName": "Example String",
    "chainAccounts": [
      {
        "__typename": "NonFungibleChainAccount"
      }
    ],
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "nonFungibleTokenBalances": [
      {
        "__typename": "NonFungibleTokenBalance"
      }
    ],
    "transactions": {
      "__typename": "NonFungibleAccountTransactionsConnection"
    },
    "transfers": {
      "__typename": "NonFungibleAccountTransfersConnection"
    }
  }
}

nonFungibleChainAccount

(...args)
NonFungibleChainAccount

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

accountName
String!,non-nullrequired

The full name of the account to retrieve. Example: "k:abcdef123456..." for a user account or "free.my-contract" for a contract account.

chainId
String!,non-nullrequired

The ID of the chain where the account exists. Kadena runs multiple braided chains, and NFT data is tracked separately on each.

Return type

NonFungibleChainAccount
accountName
String!,non-null

The full name of the account (e.g., k:abcdef123456... for a user account or free.my-contract for a contract account).

chainId
String!,non-null

The chain ID where this non-fungible account exists.

id
ID!,non-null

Globally unique identifier for this chain-scoped NFT account node.

nonFungibleTokenBalances
[NonFungibleTokenBalance!]!,non-null

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.

transactions
NonFungibleChainAccountTransactionsConnection!,non-null

Paginated list of NFT-related transactions involving this account on this chain. Transactions can include mints, transfers, or contract interactions that affect NFT state.

afterbeforefirstlast
transfers
NonFungibleChainAccountTransfersConnection!,non-null

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.

afterbeforefirstlast
Query sample
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
    }
  }
}
Variables
{
  "accountName": "Example String",
  "chainId": "Example String"
}
Response sample
{
  "data": {
    "accountName": "Example String",
    "chainId": "Example String",
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "nonFungibleTokenBalances": [
      {
        "__typename": "NonFungibleTokenBalance"
      }
    ],
    "transactions": {
      "__typename": "NonFungibleChainAccountTransactionsConnection"
    },
    "transfers": {
      "__typename": "NonFungibleChainAccountTransfersConnection"
    }
  }
}

pactQuery

(pactQuery)
[PactQueryResponse!]!,non-null

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.

Arguments

pactQuery
[PactQuery!]!,non-nullrequired

A list of Pact queries to execute. Each query specifies the chainId, code, and optional input data.

Return type

[PactQueryResponse!]!
chainId
String!,non-null

The chain ID on which the query was executed.

code
String!,non-null

The original Pact code that was executed.

error
String

Any error message returned during execution. null if the query was successful.

result
String

The raw JSON-encoded result returned by the Pact execution.

status
String!,non-null

The execution status, typically "success" or "failure".

Query sample
query pactQuery($pactQuery: [PactQuery!]!) {
  pactQuery(pactQuery: $pactQuery) {
    chainId 
    code 
    error 
    result 
    status 
  }
}
Variables
{
  "pactQuery": [
    {
      "chainId": "Example String",
      "code": "Example String",
      "data": [
        {
          "__typename": "PactQueryData"
        }
      ]
    }
  ]
}
Response sample
{
  "data": [
    {
      "chainId": "Example String",
      "code": "Example String",
      "error": "Example String",
      "result": "Example String",
      "status": "Example String"
    }
  ]
}

transaction

(...args)
Transaction

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.

Arguments

blockHash
String

The hash of the block that contains the transaction. When provided along with requestKey, guarantees a unique match. Only one such combination will correspond to a canonical block; others (if any) are from orphaned blocks.

minimumDepth
Int

The minimum depth (distance from the chain tip) the block containing the transaction must have. Useful to filter for transactions in finalized blocks.

requestKey
String!,non-nullrequired

The unique request key of the transaction. Note: The same request key can appear in multiple blocks over time due to chain reorganizations.

Return type

Transaction
id
ID!,non-null

Globally unique identifier for this transaction node.

cmd
TransactionCommand!,non-null

The original signed transaction command submitted to the network. Includes metadata, payload, signers, and network information.

hash
String!,non-null

The unique hash of the transaction. This value is derived from the signed command and serves as the canonical identifier for the transaction on-chain.

result
TransactionInfo!,non-null

The result of executing the transaction. Includes information such as success/failure status, events, continuation data, and any state changes triggered by execution.

sigs
[TransactionSignature!]!,non-null

The list of signatures associated with the transaction. Each signature proves authorization from a required signer and is used to validate that the transaction was properly authorized before execution.

Query sample
query transaction(
  $blockHash: String
  $minimumDepth: Int
  $requestKey: String!
) {
  transaction(
    blockHash: $blockHash
    minimumDepth: $minimumDepth
    requestKey: $requestKey
  ) {
    id 
    cmd {
      __typename
      # ...TransactionCommandFragment
    }
    hash 
    result {
      __typename
      # ...TransactionMempoolInfoFragment
    }
    sigs {
      __typename
      # ...TransactionSignatureFragment
    }
  }
}
Variables
{
  "blockHash": "Example String",
  "minimumDepth": 40,
  "requestKey": "Example String"
}
Response sample
{
  "data": {
    "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
    "cmd": {
      "__typename": "TransactionCommand"
    },
    "hash": "Example String",
    "result": {
      "__typename": "TransactionMempoolInfo"
    },
    "sigs": [
      {
        "__typename": "TransactionSignature"
      }
    ]
  }
}

transactions

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

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.

Arguments

accountName
String

Filter transactions involving a specific account name. Can match either the sender or recipient. Example: "k:abcdef123456...".

blockHash
String

Retrieve only transactions included in the block with this hash. Useful when inspecting all transactions within a specific block.

chainId
String

Restrict results to a specific chain ID.

fungibleName
String

Filter transactions by the fungible token module involved. Example: "coin".

maxHeight
Int

The maximum block height to include in results. Transactions in blocks above this height will be excluded.

minHeight
Int

The minimum block height to include in results. Transactions in blocks below this height will be excluded.

minimumDepth
Int

Minimum depth (distance from the chain tip) of the block containing the transaction. Use this to filter for transactions in finalized blocks.

requestKey
String

Filter by the unique request key of the transaction. Useful when looking up a specific transaction by its identifier.

isCoinbase
Boolean

When true, returns only coinbase transactions — block reward transactions created during mining.

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 transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsConnection!
edges
[QueryTransactionsConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transactions(
  $accountName: String
  $blockHash: String
  $chainId: String
  $fungibleName: String
  $maxHeight: Int
  $minHeight: Int
  $minimumDepth: Int
  $requestKey: String
  $isCoinbase: Boolean
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactions(
    accountName: $accountName
    blockHash: $blockHash
    chainId: $chainId
    fungibleName: $fungibleName
    maxHeight: $maxHeight
    minHeight: $minHeight
    minimumDepth: $minimumDepth
    requestKey: $requestKey
    isCoinbase: $isCoinbase
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        cmd {
          __typename
          # ...TransactionCommandFragment
        }
        hash 
        result {
          __typename
          # ...TransactionMempoolInfoFragment
        }
        sigs {
          __typename
          # ...TransactionSignatureFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "accountName": "Example String",
  "blockHash": "Example String",
  "chainId": "Example String",
  "fungibleName": "Example String",
  "maxHeight": 40,
  "minHeight": 40,
  "minimumDepth": 40,
  "requestKey": "Example String",
  "isCoinbase": true,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "cmd": {
            "__typename": "TransactionCommand"
          },
          "hash": "Example String",
          "result": {
            "__typename": "TransactionMempoolInfo"
          },
          "sigs": [
            {
              "__typename": "TransactionSignature"
            }
          ]
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

transactionsByPublicKey

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

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.

Arguments

publicKey
String!,non-nullrequired

The public key to filter transactions by. Example: "abcdef1234567890...".

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 transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsByPublicKeyConnection!
edges
[QueryTransactionsByPublicKeyConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transactionsByPublicKey(
  $publicKey: String!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactionsByPublicKey(
    publicKey: $publicKey
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        cmd {
          __typename
          # ...TransactionCommandFragment
        }
        hash 
        result {
          __typename
          # ...TransactionMempoolInfoFragment
        }
        sigs {
          __typename
          # ...TransactionSignatureFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "publicKey": "Example String",
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "cmd": {
            "__typename": "TransactionCommand"
          },
          "hash": "Example String",
          "result": {
            "__typename": "TransactionMempoolInfo"
          },
          "sigs": [
            {
              "__typename": "TransactionSignature"
            }
          ]
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

transactionsByPactCode

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

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.

Arguments

pactCode
String!,non-nullrequired

The exact Pact code to filter transactions by. Only transactions that executed this code will be returned. Example: "(coin.transfer \\\"k:abc...\\\" \\\"k:def...\\\" 1.0)"

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 transactions to return when paginating forward.

last
Int

Maximum number of transactions to return when paginating backward.

Return type

QueryTransactionsByPactCodeConnection!
edges
[QueryTransactionsByPactCodeConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query transactionsByPactCode(
  $pactCode: String!
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transactionsByPactCode(
    pactCode: $pactCode
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        requestKey 
        height 
        chainId 
        canonical 
        creationTime 
        badResult 
        sender 
        gas 
        gasLimit 
        gasPrice 
        code 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "pactCode": "Example String",
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "requestKey": "Example String",
          "height": "Example Custom Scalar",
          "chainId": "Example Custom Scalar",
          "canonical": true,
          "creationTime": "Example Custom Scalar",
          "badResult": "Example String",
          "sender": "Example String",
          "gas": "Example String",
          "gasLimit": "Example String",
          "gasPrice": "Example String",
          "code": "Example String"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

transfers

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

Retrieve a paginated list of token transfers with flexible filtering options.

This query returns on-chain transfer events — movements of tokens from one account to another — and supports filtering by block, transaction, account, chain, token type, and more. It is commonly used by explorers, wallets, and analytics tools to display account activity, track token movements, and analyze on-chain transfers.

Transfers can represent either fungible tokens (like coin for KDA) or non-fungible tokens (NFTs), depending on the isNFT flag.

You can combine multiple filters to narrow down results. For example:

  • Filter by accountName to retrieve all incoming and outgoing transfers for a specific account.
  • Use blockHash to get all transfers included in a particular block.
  • Combine chainId and fungibleName to target transfers of a specific token on a specific chain.
  • Provide a requestKey to return transfers associated with a specific transaction.
  • Set isNFT: true to return only NFT transfers.

⚠️ Important: fungibleName cannot be used when isNFT is set to true. NFT transfers do not belong to a fungible token module, so this parameter must be omitted in that case.

Arguments

blockHash
String

Retrieve only transfers included in the block with this hash. Useful when analyzing all token movements in a specific block.

requestKey
String

Filter by the unique request key of the transaction that emitted the transfer.

accountName
String

Filter transfers involving a specific account. Matches both senders and recipients.

chainId
String

Restrict results to transfers that occurred on a specific chain.

fungibleName
String

Filter transfers by the fungible token module involved. Example: "coin". ⚠️ Cannot be used if isNFT is set to true.

isNFT
Boolean

Set to true to retrieve only non-fungible token (NFT) transfers. When false or omitted, only fungible token transfers are returned.

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 transfers to return when paginating forward.

last
Int

Maximum number of transfers to return when paginating backward.

Return type

QueryTransfersConnection!
edges
[QueryTransfersConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query transfers(
  $blockHash: String
  $requestKey: String
  $accountName: String
  $chainId: String
  $fungibleName: String
  $isNFT: Boolean
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  transfers(
    blockHash: $blockHash
    requestKey: $requestKey
    accountName: $accountName
    chainId: $chainId
    fungibleName: $fungibleName
    isNFT: $isNFT
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        amount 
        block {
          __typename
          # ...BlockFragment
        }
        blockHash 
        chainId 
        creationTime 
        crossChainTransfer {
          __typename
          # ...TransferFragment
        }
        height 
        id 
        moduleHash 
        moduleName 
        orderIndex 
        receiverAccount 
        requestKey 
        senderAccount 
        tokenId 
        transaction {
          __typename
          # ...TransactionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "blockHash": "Example String",
  "requestKey": "Example String",
  "accountName": "Example String",
  "chainId": "Example String",
  "fungibleName": "Example String",
  "isNFT": true,
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "amount": "Example Custom Scalar",
          "block": {
            "__typename": "Block"
          },
          "blockHash": "Example String",
          "chainId": "Example Custom Scalar",
          "creationTime": "Example Custom Scalar",
          "crossChainTransfer": {
            "__typename": "Transfer"
          },
          "height": "Example Custom Scalar",
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "moduleHash": "Example String",
          "moduleName": "Example String",
          "orderIndex": "Example Custom Scalar",
          "receiverAccount": "Example String",
          "requestKey": "Example String",
          "senderAccount": "Example String",
          "tokenId": "Example String",
          "transaction": {
            "__typename": "Transaction"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

tokens

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

Retrieve a paginated list of all tokens deployed on the Kadena network, excluding the native coin token.

This query returns both fungible tokens and non-fungible token contracts (currently limited to marmalade and marmalade-v2), providing basic metadata such as the token’s name, deployment chain, and contract address.

It is commonly used by explorers, indexers, and dApps to discover tokens deployed on-chain, list available assets, or build token selection interfaces. The results are network-wide and not limited to a specific module or account.

Arguments

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 tokens to return when paginating forward.

last
Int

Maximum number of tokens to return when paginating backward.

Return type

QueryTokensConnection!
edges
[QueryTokensEdge!]!,non-null
pageInfo
PageInfo!,non-null
Query sample
query tokens(
  $after: String
  $before: String
  $first: Int
  $last: Int
) {
  tokens(
    after: $after
    before: $before
    first: $first
    last: $last
  ) {
    edges {
      cursor 
      node {
        id 
        name 
        chainId 
        address 
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
  }
}
Variables
{
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "name": "Example String",
          "chainId": "Example String",
          "address": "Example String"
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    }
  }
}

pools

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

Retrieve a paginated list of liquidity pools with sorting and optional protocol filtering.

This query returns AMM pools (currently sourced from a single protocol used by the Sushi team) including reserves, TVL (USD), volume, fees, APR, and recent activity metrics. Prices for TVL/volume/fees are computed using DIA data (https://api.diadata.org) refreshed approximately every 5 minutes.

Use orderBy to sort by TVL, 24h/7d volume, 24h APR, or 24h transaction count (ASC/DESC), and protocolAddress to limit results to a specific protocol/module name on Kadena. Results support cursor-based pagination.

Arguments

after
String

Cursor to start paginating after a specific result (forward pagination).

before
String

Cursor to start paginating before a specific result (backward pagination).

first
Int

Maximum number of pools to return when paginating forward.

last
Int

Maximum number of pools to return when paginating backward.

orderBy
PoolOrderBy
Default:"TVL_USD_DESC"

Sort order for the returned pools.

protocolAddress
String

The protocol/module name (on Kadena) to filter by. Use this to restrict results to a specific DEX implementation.

Return type

QueryPoolsConnection!
edges
[QueryPoolsConnectionEdge!]!,non-null
pageInfo
PageInfo!,non-null
totalCount
Int!,non-null
Query sample
query pools(
  $after: String
  $before: String
  $first: Int
  $last: Int
  $orderBy: PoolOrderBy
  $protocolAddress: String
) {
  pools(
    after: $after
    before: $before
    first: $first
    last: $last
    orderBy: $orderBy
    protocolAddress: $protocolAddress
  ) {
    edges {
      cursor 
      node {
        id 
        address 
        token0 {
          __typename
          # ...TokenFragment
        }
        token1 {
          __typename
          # ...TokenFragment
        }
        reserve0 
        reserve1 
        totalSupply 
        key 
        tvlUsd 
        tvlChange24h 
        volume24hUsd 
        volumeChange24h 
        volume7dUsd 
        fees24hUsd 
        feesChange24h 
        transactionCount24h 
        transactionCountChange24h 
        apr24h 
        createdAt 
        updatedAt 
        charts(
          # Arguments Here
        ) {
          __typename
          # ...PoolChartsFragment
        }
        transactions(
          # Arguments Here
        ) {
          __typename
          # ...PoolTransactionsConnectionFragment
        }
      }
    }
    pageInfo {
      startCursor 
      endCursor 
      hasNextPage 
      hasPreviousPage 
    }
    totalCount 
  }
}
Variables
{
  "after": "Example String",
  "before": "Example String",
  "first": 40,
  "last": 40,
  "orderBy": "TVL_USD_ASC",
  "protocolAddress": "Example String"
}
Response sample
{
  "data": {
    "edges": [
      {
        "cursor": "Example String",
        "node": {
          "id": "9cfb1c81-4c79-452f-b1f5-8ee6571276b4",
          "address": "Example String",
          "token0": {
            "__typename": "Token"
          },
          "token1": {
            "__typename": "Token"
          },
          "reserve0": "Example String",
          "reserve1": "Example String",
          "totalSupply": "Example String",
          "key": "Example String",
          "tvlUsd": 40,
          "tvlChange24h": 40,
          "volume24hUsd": 40,
          "volumeChange24h": 40,
          "volume7dUsd": 40,
          "fees24hUsd": 40,
          "feesChange24h": 40,
          "transactionCount24h": 40,
          "transactionCountChange24h": 40,
          "apr24h": 40,
          "createdAt": "Example Custom Scalar",
          "updatedAt": "Example Custom Scalar",
          "charts": {
            "__typename": "PoolCharts"
          },
          "transactions": {
            "__typename": "PoolTransactionsConnection"
          }
        }
      }
    ],
    "pageInfo": {
      "startCursor": "Example String",
      "endCursor": "Example String",
      "hasNextPage": true,
      "hasPreviousPage": true
    },
    "totalCount": 40
  }
}

Subscriptions

Overview

Directives

Overview

Objects

Overview

Interfaces

Overview

Unions

Overview

Enums

Overview

Inputs

Overview

Scalars

Overview