API Documentation

169 methods

Root JSON-RPC

Espo's own built-in methods, available without a module prefix. Proxies onto the 比特币 backends live under btc.* instead.

get_espo_heightJSON-RPC

Returns the latest Espo indexed height. Use this as the health and freshness check for clients.

Clients commonly call this before pagination or historical reads so they can tell whether the explorer is caught up to the chain tip they expect.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "get_espo_height",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "height": 946000
  },
  "id": 1
}
get_method_line_chartJSON-RPC

Samples a numeric value from another RPC method across indexed heights and returns chart-ready points.

The chart method calls another numeric RPC repeatedly over a height range, so choose a narrow interval when you need quick responses.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "get_method_line_chart",
  "params": {
    "method": "essentials.get_holders_count",
    "key": "count",
    "body": {
      "alkane": "2:0"
    },
    "range_min": 945900,
    "range_max": 946000,
    "range_interval": 25
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "method": "essentials.get_holders_count",
    "key": "count",
    "range_min": 945900,
    "range_max": 946000,
    "range_interval": 25,
    "points": [
      {
        "height": 945900,
        "value": 6409
      },
      {
        "height": 945925,
        "value": 6407
      }
    ]
  },
  "id": 1
}

Bitcoin JSON-RPC (btc.*)

Proxies onto the configured 比特币 backends: electrs/Esplora for transaction and address reads, 比特币 Core for broadcast and package submission. Nothing here is served from Espo's own indices, and the read methods return their backend's response shape unchanged.

btc.get_transactionJSON-RPC

Returns one transaction in the configured electrs/Esplora JSON shape, passed through unchanged, together with its raw hex. Covers mempool as well as confirmed transactions. A transaction the index has never seen returns ok with found false rather than an error. Requires electrs_esplora_url; native Electrum RPC does not expose this shape.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "btc.get_transaction",
  "params": {
    "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "found": true,
    "tx": {
      "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
      "version": 2,
      "locktime": 0,
      "vin": [
        {
          "txid": "a44d1f42e1eb15b779f75089cd496f61b73ef68d411d09701ebd9ea51ade7cf8",
          "vout": 3,
          "prevout": {
            "scriptpubkey_address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
            "value": 546
          },
          "sequence": 4294967293
        }
      ],
      "vout": [
        {
          "scriptpubkey_address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
          "value": 546
        }
      ],
      "size": 312,
      "weight": 792,
      "fee": 1410,
      "status": {
        "confirmed": true,
        "block_height": 946000,
        "block_hash": "00000000000000000000f0b2e1a4f2ae1b0b0f4a6f0b2e1a4f2ae1b0b0f4a6f0",
        "block_time": 1741000000
      }
    },
    "hex": "0200000000010..."
  },
  "id": 1
}
btc.get_addressJSON-RPC

Returns the configured electrs/Esplora address summary without changing its field names or response shape. This method requires electrs_esplora_url; native Electrum RPC does not expose the exact aggregate statistics.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "btc.get_address",
  "params": {
    "address": "1wiz18xYmhRX6xStj2b9t1rwWX4GKUgpv"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "address": "1wiz18xYmhRX6xStj2b9t1rwWX4GKUgpv",
    "chain_stats": {
      "funded_txo_count": 11,
      "funded_txo_sum": 15007688098,
      "spent_txo_count": 5,
      "spent_txo_sum": 15007599040,
      "tx_count": 13
    },
    "mempool_stats": {
      "funded_txo_count": 0,
      "funded_txo_sum": 0,
      "spent_txo_count": 0,
      "spent_txo_sum": 0,
      "tx_count": 0
    }
  },
  "id": 1
}
btc.broadcast_transactionJSON-RPC

Broadcasts a raw 比特币 transaction through the configured electrs or Esplora backend, with 比特币 Core as a fallback.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "btc.broadcast_transaction",
  "params": {
    "raw_tx": "0200000001..."
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90"
  },
  "id": 1
}
btc.submit_packageJSON-RPC

Submits related raw transactions to 比特币 Core together through submitpackage, for cases one-at-a-time broadcasting cannot express — a child paying for its parent, most often. Order them parents first, at most 25. Core's per-transaction reply is passed through untouched under `result`, since a package can partly succeed. There is no Esplora fallback: package submission exists only on Core.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "btc.submit_package",
  "params": {
    "txs": [
      "0200000001...parent...",
      "0200000001...child..."
    ]
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "result": {
      "package_msg": "success",
      "tx-results": {
        "e3f1...": {
          "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
          "vsize": 141,
          "fees": {
            "base": 1.41e-6
          }
        }
      },
      "replaced-transactions": []
    }
  },
  "id": 1
}
btc.fee_estimatesJSON-RPC

Returns precise sat/vB fee recommendations derived from Espo's projected mempool blocks. The fields match mempool.space's precise fee response shape.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "btc.fee_estimates",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "fastest手续费": 1.017,
    "halfHour手续费": 0.722,
    "hour手续费": 0.448,
    "economy手续费": 0.2,
    "minimum手续费": 0.1
  },
  "id": 1
}

Essentials JSON-RPC

Core Alkane, address, outpoint, trace, holder, and mempool reads.

essentials.get_mempool_txJSON-RPC

Returns one pending transaction's projected traces by txid, along with its projected mempool block and trace-status flags. Answers found false when the transaction is not in the mempool. The traces carry the same outpoint/events shape as get_block_traces, so one reconstruction covers pending and confirmed transactions alike; a remote explorer uses this to render an unconfirmed transaction's estimated trace and call summary, which it cannot project itself.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_mempool_tx",
  "params": {
    "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "found": true,
    "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
    "first_seen": 1785100016,
    "mempool_block": 0,
    "mempool_position_vsize": 141,
    "defer_alkane_trace_status": false,
    "has_alkane_action": true,
    "has_rune_action": false,
    "traces": [
      {
        "outpoint": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90:3",
        "events": [
          {
            "event": "invoke",
            "data": {
              "type": "call",
              "context": {
                "myself": {
                  "block": "0x2",
                  "tx": "0x0"
                },
                "inputs": [
                  "0x4d",
                  "0x0"
                ]
              }
            }
          }
        ]
      }
    ]
  },
  "id": 1
}
essentials.get_mempool_tracesJSON-RPC

Returns paged Alkane traces from the in-memory projected mempool index, optionally filtered by address and minimum sats/vbyte paid via fee_paid. Results are ordered by projected mempool block with the next block first, then by fee paid within that block.

Use this for unconfirmed Alkane activity previews; results can disappear or change when transactions are replaced, evicted, or mined.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_mempool_traces",
  "params": {
    "page": 1,
    "limit": 10,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "fee_paid": 2.16
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 10,
    "has_more": false,
    "total": 1,
    "tx_total": 1,
    "items": [
      {
        "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
        "mempool_block": 0,
        "fee_sat": 1540,
        "fee_paid": 10.0,
        "fee_rate": 10.0,
        "vsize": 154,
        "protostone": [
          {
            "protocol_tag": 1,
            "message": "02000000000000000000000000000000",
            "edicts": [],
            "pointer": null,
            "refund": null,
            "from": null,
            "burn": null
          }
        ],
        "traces": [
          {
            "outpoint": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90:0",
            "events": [
              {
                "event": "invoke",
                "data": {
                  "context": {
                    "myself": {
                      "block": "0x2",
                      "tx": "0x0"
                    }
                  }
                }
              }
            ]
          }
        ]
      }
    ]
  },
  "id": 1
}
essentials.get_mempool_memory_statsJSON-RPC

Returns in-memory mempool service counters when the mempool service is active.

This is an operational endpoint intended for monitoring and debugging a running Espo node rather than user-facing portfolio state.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_mempool_memory_stats",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "stats": {
      "txs": 1200,
      "projected_blocks": 8
    }
  },
  "id": 1
}
essentials.get_keysJSON-RPC

Reads contract storage keys for an Alkane. Provide explicit keys or page through the key directory.

Storage keys are low-level contract state. Values may be binary, encoded integers, or UTF-8 text depending on the contract convention.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_keys",
  "params": {
    "alkane": "2:0",
    "keys": [
      "name"
    ],
    "try_decode_utf8": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "total": 1,
    "items": {
      "name": {
        "key_hex": "0x6e616d65",
        "key_str": "name",
        "value_hex": "0x",
        "value_str": null
      }
    }
  },
  "id": 1
}
essentials.get_all_alkanesJSON-RPC

Lists Alkane creation records with basic metadata. When only a name or symbol is indexed, the missing scalar field falls back to the available value; name-to-symbol fallbacks are uppercased. The raw names and symbols arrays remain unchanged.

These list and search methods are designed for discovery screens. They return indexed metadata, not live contract execution results.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_all_alkanes",
  "params": {
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 1,
    "total": 77735,
    "items": [
      {
        "alkane": "2:77579",
        "name": "Beep Boop Orbited #1376",
        "symbol": "BEEP BOOP ORBITED #1376",
        "holder_count": 1
      }
    ]
  },
  "id": 1
}
essentials.search_alkaneJSON-RPC

搜索es indexed Alkane names and symbols by a case-insensitive prefix. Exact matches rank first, followed by holder count. limit defaults to 20 and is capped at 100. A missing symbol falls back to the uppercased name, and a missing name falls back to the symbol.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.search_alkane",
  "params": {
    "prefix": "die",
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "prefix": "die",
    "limit": 10,
    "items": [
      {
        "alkane": "2:0",
        "name": "DIESEL",
        "symbol": "diesel",
        "holder_count": 6409,
        "creation_height": 880000
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_infoJSON-RPC

Returns the creation metadata, names, icon, and indexed details for one Alkane. A missing scalar symbol falls back to the uppercased name, and a missing scalar name falls back to the symbol.

Use this when you already know the Alkane id and need the explorer's normalized metadata, display fields, and indexed creation context.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_info",
  "params": {
    "alkane": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "name": "DIESEL",
    "symbol": "diesel",
    "holder_count": 6409,
    "creation_height": 880000
  },
  "id": 1
}
essentials.get_alkabiJSON-RPC

Extracts a contract's Alkabi ABI from its indexed WASM and synthesizes verified static plans for reducible view methods. Set format to json to return the ABI as a JSON object, or ts to return a generated TypeScript module string. Proxy implementations and 工厂克隆s resolve through the same indexed metadata used by the explorer's contract inspector. An optional height selects the indexed proxy and factory metadata at that height.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • With `format: "json"`, `abi` is a JSON object. With `format: "ts"`, `abi` is a string containing a complete generated TypeScript module.
  • Proxy contracts resolve their indexed implementation recursively, and 工厂克隆s use their indexed factory WASM before Alkabi extraction.
  • Espo uses the top-level `alkabi_verify_trials` config value, which defaults to 128 and must be greater than zero. Reducible view methods include a verified `plan`; unsupported views omit it so consumers can fall back to simulation.
  • When top-level config `db_cache` is true, analyzed exports are persisted by network, resolved immutable WASM source, and verification trial count in `${db_path}/cache`. Concurrent misses for the same source and trial count share one job and wait for its cached result.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkabi",
  "params": {
    "alkane": "2:0",
    "format": "json"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "format": "json",
    "abi": {
      "alkabi": 1,
      "contract": "GenesisAlkane",
      "types": {},
      "methods": [
        {
          "name": "mint",
          "opcode": 77,
          "kind": "execute"
        }
      ]
    }
  },
  "id": 1
}
essentials.get_alkane_wasmJSON-RPC

Returns a contract's WASM bytecode, resolving proxy implementations and 工厂克隆s through the same indexed metadata as the explorer's /api/alkane/wasm/export download. The payload is base64-encoded; set gzip to true to compress it first (encoding becomes base64+gzip, typically ~3x smaller). sha256 and length always describe the raw wasm regardless of transport encoding, and source reports which Alkane actually provided the bytecode after resolution — 工厂克隆s and proxies sharing one binary resolve to the same source, so caches can dedup and content-address payloads. Set resolve to false (or no_resolution to true) to load exactly what the alkanes runtime's get_alkane_binary would: read /alkanes/{id}, recurse when the payload is a 32-byte factory pointer, otherwise gunzip — no /implementation or /beacon hop, so a proxy returns its own bytecode rather than its implementation's. That mode also loads the CURRENT stored payload, which for upgraded built-ins (DIESEL 2:0, frBTC 32:0, frSIGIL 32:1) is the binary the runtime executes today; pass first_version to get the original payload instead (the default resolved path always reports the first version). The response envelope is identical in both modes.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • Cache by `sha256` (or `source`) rather than by the requested Alkane id: plain contracts are immutable, but a proxy's resolved `source` changes if its implementation is repointed.
  • The payload decodes with standard base64; when `encoding` is `base64+gzip`, gunzip the decoded bytes to recover the raw wasm. `sha256` and `length` always describe the raw wasm.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_wasm",
  "params": {
    "alkane": "2:0",
    "gzip": true,
    "resolve": false
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "source": "2:0",
    "length": 174225,
    "sha256": "58cca703f5462c733975c068c6d1e245cc32941741f4b6e61a468257b4b5ffb6",
    "encoding": "base64+gzip",
    "payload_length": 63504,
    "wasm_base64": "H4sIAAAAAAAC/..."
  },
  "id": 1
}
essentials.get_factory_childrenJSON-RPC

Returns child Alkane IDs indexed for a factory Alkane. The index is populated from creation records as new blocks are indexed; historical children appear after a reindex.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_factory_children",
  "params": {
    "factory": "4:780993"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "factory": "4:780993",
    "children": [
      "2:80663"
    ]
  },
  "id": 1
}
essentials.search_factory_keysJSON-RPC

搜索es a factory's children for contracts whose storage keys satisfy conditions. Conditions are ANDed and each requires the key to exist: eq and ne compare raw bytes (value as utf8 string or 0x-hex), gt, lt, ge and le decode the stored value as a little-endian u128 (value as decimal or 0x-hex, number or string), and exists matches any present value. A single condition can be passed as top-level key, op and value instead of the conditions array. Matched values are echoed per key in the same shape as get_keys items. Scoped to a factory by design: the scan resolves the factory-children index and does batched point lookups, capped at 8 conditions, 50,000 children and limit 1000.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • An absent key never matches any operator — including `ne` — so contracts that never set the key are excluded rather than treated as "different value".
  • Numeric operators decode the stored value as a little-endian u128 and only match values of 16 bytes or fewer; `eq`/`ne` compare the exact raw bytes. Results are ordered by child id (block, then tx), so pagination is deterministic.
  • There is deliberately no unscoped variant: the factory requirement keeps the scan bounded to batched point lookups over the factory-children index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.search_factory_keys",
  "params": {
    "factory": "4:780993",
    "conditions": [
      {
        "key": "/collateral_address",
        "op": "eq",
        "value": "bc1q..."
      },
      {
        "key": "/fire_amount",
        "op": "gt",
        "value": "13000000"
      }
    ],
    "page": 1,
    "limit": 100
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "factory": "4:780993",
    "conditions": [
      {
        "key": "0x2f636f6c6c61746572616c5f61646472657373",
        "key_str": "/collateral_address",
        "op": "eq",
        "value": "0x626331712e2e2e"
      },
      {
        "key": "0x2f666972655f616d6f756e74",
        "key_str": "/fire_amount",
        "op": "gt",
        "value": "13000000"
      }
    ],
    "page": 1,
    "limit": 100,
    "total": 1,
    "has_more": false,
    "items": [
      {
        "alkane": "2:80663",
        "keys": {
          "/collateral_address": {
            "key_hex": "0x2f636f6c6c61746572616c5f61646472657373",
            "key_str": "/collateral_address",
            "value_hex": "0x626331712e2e2e",
            "value_str": "bc1q...",
            "value_u128": null,
            "last_txid": "84ec..."
          },
          "/fire_amount": {
            "key_hex": "0x2f666972655f616d6f756e74",
            "key_str": "/fire_amount",
            "value_hex": "0x406f400100000000",
            "value_str": null,
            "value_u128": "21000000",
            "last_txid": "84ec..."
          }
        }
      }
    ]
  },
  "id": 1
}
essentials.get_block_summaryJSON-RPC

Returns the indexed summary, canonical block hash, serialized header, and exact Unix block time for a block height.

区块 summaries are aggregated during indexing and are useful for block pages, progress checks, and quickly finding Alkane-heavy blocks.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_block_summary",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "found": true,
    "blockhash": "0000000000000000000000000000000000000000000000000000000000000000",
    "header_hex": "00000020...",
    "block_time": 1779308930,
    "tx_count": 2864,
    "trace_count": 38,
    "interaction_count": 60,
    "pool": {
      "name": "AntPool",
      "slug": "antpool"
    }
  },
  "id": 1
}
essentials.get_block_timeJSON-RPC

Returns the exact Unix timestamp from the canonical indexed block header at one height.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_block_time",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "found": true,
    "block_time": 1779308930
  },
  "id": 1
}
essentials.get_block_timesJSON-RPC

Returns exact Unix timestamps for up to 1,000 canonical indexed block heights in request order.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_block_times",
  "params": {
    "heights": [
      945999,
      946000
    ]
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "times": [
      {
        "height": 945999,
        "found": true,
        "block_time": 1779308321
      },
      {
        "height": 946000,
        "found": true,
        "block_time": 1779308930
      }
    ]
  },
  "id": 1
}
essentials.get_holdersJSON-RPC

Returns holders and balances for an Alkane.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_holders",
  "params": {
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "page": 1,
    "limit": 1,
    "total": 6409,
    "items": [
      {
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "30950001348973"
      }
    ]
  },
  "id": 1
}
essentials.get_orbital_holdersJSON-RPC

Returns holders for an orbital factory, counting each child Alkane held as one unit and listing the child Alkane IDs held by each holder.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_orbital_holders",
  "params": {
    "factory": "4:780993",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "factory": "4:780993",
    "page": 1,
    "limit": 1,
    "total": 249,
    "items": [
      {
        "type": "address",
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "3",
        "alkanes": [
          "2:80663",
          "2:80664",
          "2:80665"
        ]
      }
    ]
  },
  "id": 1
}
essentials.get_orbital_balancesJSON-RPC

Returns orbital child Alkane balances held by an address, keyed by factory Alkane.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_orbital_balances",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "balances": {
      "4:780993": {
        "amount": "3",
        "alkanes": [
          "2:80663",
          "2:80664",
          "2:80665"
        ]
      }
    }
  },
  "id": 1
}
essentials.get_transfer_volumeJSON-RPC

Ranks addresses by cumulative transfer volume for an Alkane.

These ranking endpoints are useful for leaderboards and analytics, but they should not be treated as spendable balance calculations.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_transfer_volume",
  "params": {
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "page": 1,
    "limit": 1,
    "total": 23936,
    "items": [
      {
        "address": "bc1qnlaz6rt6734pfd23ehx68nyczs5pfjdp6ct0aa",
        "amount": "3864636702544018"
      }
    ]
  },
  "id": 1
}
essentials.get_total_receivedJSON-RPC

Ranks addresses by total received amount for an Alkane.

These ranking endpoints are useful for leaderboards and analytics, but they should not be treated as spendable balance calculations.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_total_received",
  "params": {
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "page": 1,
    "limit": 1,
    "total": 23936,
    "items": [
      {
        "address": "bc1qnlaz6rt6734pfd23ehx68nyczs5pfjdp6ct0aa",
        "amount": "3863765984261495"
      }
    ]
  },
  "id": 1
}
essentials.get_circulating_supplyJSON-RPC

Returns the circulating supply for an Alkane at latest or at a requested height.

Supply is reported as the raw indexed token amount. Apply token decimals or display scaling in the client when presenting it to users.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_circulating_supply",
  "params": {
    "alkane": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "height": "latest",
    "supply": "62907254954708"
  },
  "id": 1
}
essentials.get_address_activityJSON-RPC

Returns Alkane activity detected for a 比特币 address.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_address_activity",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "total_received": {
      "2:0": "357260014838703"
    },
    "transfer_volume": {
      "2:0": "357810014838703"
    }
  },
  "id": 1
}
essentials.address_cumulative_send_alkanesJSON-RPC

Returns cumulative address sends attributed to source Alkanes and tokens.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.address_cumulative_send_alkanes",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "kind": "send",
    "items": [
      {
        "source_alkane": "2:0",
        "alkane": "2:0",
        "amount": "715000000"
      }
    ]
  },
  "id": 1
}
essentials.address_cumulative_receive_alkanesJSON-RPC

Returns cumulative address receives attributed to source Alkanes and tokens.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.address_cumulative_receive_alkanes",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "kind": "receive",
    "items": [
      {
        "source_alkane": "2:0",
        "alkane": "2:0",
        "amount": "312500000"
      }
    ]
  },
  "id": 1
}
essentials.address_cumulative_send_orbitalsJSON-RPC

Returns cumulative address sends attributed to factory orbitals and tokens.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.address_cumulative_send_orbitals",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "kind": "send",
    "items": [
      {
        "orbital": "2:0",
        "alkane": "4:3",
        "amount": "1"
      }
    ]
  },
  "id": 1
}
essentials.address_cumulative_receive_orbitalsJSON-RPC

Returns cumulative address receives attributed to factory orbitals and tokens.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.address_cumulative_receive_orbitals",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "kind": "receive",
    "items": [
      {
        "orbital": "2:0",
        "alkane": "4:3",
        "amount": "1"
      }
    ]
  },
  "id": 1
}
essentials.get_orbital_send_volumesJSON-RPC

Ranks addresses by cumulative send volume attributed to an orbital for one Alkane token.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_orbital_send_volumes",
  "params": {
    "factory": "4:780993",
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "factory": "4:780993",
    "alkane": "2:0",
    "kind": "send",
    "page": 1,
    "limit": 1,
    "total": 249,
    "items": [
      {
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "12"
      }
    ]
  },
  "id": 1
}
essentials.get_orbital_receive_volumesJSON-RPC

Ranks addresses by cumulative receive volume attributed to an orbital for one Alkane token.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_orbital_receive_volumes",
  "params": {
    "factory": "4:780993",
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "factory": "4:780993",
    "alkane": "2:0",
    "kind": "receive",
    "page": 1,
    "limit": 1,
    "total": 249,
    "items": [
      {
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "12"
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_send_volumesJSON-RPC

Ranks addresses by cumulative send volume attributed to one source Alkane for one Alkane token.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_send_volumes",
  "params": {
    "source_alkane": "2:1",
    "alkane": "4:3",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "source_alkane": "2:1",
    "alkane": "4:3",
    "kind": "send",
    "page": 1,
    "limit": 1,
    "total": 249,
    "items": [
      {
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "12"
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_receive_volumesJSON-RPC

Ranks addresses by cumulative receive volume attributed to one source Alkane for one Alkane token.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_receive_volumes",
  "params": {
    "source_alkane": "2:1",
    "alkane": "4:3",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "source_alkane": "2:1",
    "alkane": "4:3",
    "kind": "receive",
    "page": 1,
    "limit": 1,
    "total": 249,
    "items": [
      {
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "amount": "12"
      }
    ]
  },
  "id": 1
}
essentials.get_address_balancesJSON-RPC

Returns all Alkane balances held by an address. Set include_outpoints to include UTXO-level entries.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
  • Including outpoints returns larger payloads and is intended for wallet or account-detail views.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_address_balances",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "include_outpoints": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "balances": {
      "2:0": "30950001348973",
      "2:68441": "31612184088"
    },
    "outpoints": [
      {
        "outpoint": "ee46dd269ba0f826b0dc9f78de1875fab3ab80983e51e741ffdfa6f3b7d4aef7:0"
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_balancesJSON-RPC

Returns holders and balances for a specific Alkane, optionally at a historical height.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_balances",
  "params": {
    "alkane": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "balances": {}
  },
  "id": 1
}
essentials.get_alkane_balance_metashrewJSON-RPC

Reads a single owner/token balance using the metashrew-compatible balance path.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_balance_metashrew",
  "params": {
    "owner": "2:53014",
    "alkane": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "owner": "2:53014",
    "alkane": "2:0",
    "balance": "37604481010"
  },
  "id": 1
}
essentials.get_alkane_balance_txsJSON-RPC

Lists balance-changing transactions for an Alkane with cursor pagination.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_balance_txs",
  "params": {
    "alkane": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "2:0",
    "page": 1,
    "limit": 1,
    "total": 61235,
    "txids": [
      {
        "height": 946000,
        "txid": "d39685c77b1af6b1734c07990f116cc71f301c33a7f8448c5db90720765d8902",
        "outflow": {
          "2:0": "-8128760"
        }
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_balance_txs_by_tokenJSON-RPC

Lists balance-changing transactions for one owner and token.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_balance_txs_by_token",
  "params": {
    "owner": "2:53014",
    "token": "2:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "owner": "2:53014",
    "token": "2:0",
    "page": 1,
    "limit": 1,
    "total": 2918,
    "txids": [
      {
        "height": 945956,
        "txid": "9f825c8e8b83828b499d4754d5ad5cdfe9d6086fa67c1bb1489b56d354241e15",
        "outflow": {
          "2:0": "1000000",
          "2:16": "-14061191674"
        }
      }
    ]
  },
  "id": 1
}
essentials.get_outpoint_balancesJSON-RPC

Returns Alkane balances assigned to a specific outpoint.

Outpoint-level responses are the most precise way to understand which UTXOs carry token state before constructing a transaction.

What to know
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_outpoint_balances",
  "params": {
    "outpoint": "ee46dd269ba0f826b0dc9f78de1875fab3ab80983e51e741ffdfa6f3b7d4aef7:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "outpoint": "ee46dd269ba0f826b0dc9f78de1875fab3ab80983e51e741ffdfa6f3b7d4aef7:0",
    "items": [
      {
        "alkane": "2:0",
        "amount": "30950001348973"
      }
    ]
  },
  "id": 1
}
essentials.get_runtime_balances_metashrewJSON-RPC

Returns the protocol's runtime balance sheet — Alkanes held by the runtime itself rather than by any outpoint. Takes no parameters; there is one sheet for the whole protocol, and it is always read at the metashrew tip (a `height` is validated like every other method here but does not select a historical sheet). Entries use the same shape as the ones inside get_outpoint_balances, minus the outpoint, and are ordered by Alkane id.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_runtime_balances_metashrew",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "entries": [
      {
        "alkane": "2:0",
        "amount": "9445870526523"
      }
    ]
  },
  "id": 1
}
essentials.get_block_tracesJSON-RPC

Returns Alkane traces indexed for a block height.

Trace data explains contract execution, emitted events, and state changes. It is heavier than summary data and should be paged or scoped where possible.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_block_traces",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "traces": [
      {
        "outpoint": "a44d1f42e1eb15b779f75089cd496f61b73ef68d411d09701ebd9ea51ade7cf8:3",
        "events": [
          {
            "event": "invoke",
            "data": {
              "type": "call",
              "fuel": 25382538,
              "context": {
                "myself": {
                  "block": "0x2",
                  "tx": "0x0"
                },
                "caller": {
                  "block": "0x0",
                  "tx": "0x0"
                },
                "vout": 3,
                "inputs": [
                  "0x4d",
                  "0x0"
                ]
              }
            }
          },
          {
            "event": "return",
            "data": {
              "status": "success",
              "response": {
                "alkanes": [
                  {
                    "id": {
                      "block": "0x2",
                      "tx": "0x0"
                    },
                    "value": "0x2330ba25"
                  }
                ],
                "data": "0x",
                "storage": [
                  {
                    "key": "/fees",
                    "value": "0x9f478513110000000000000000000000"
                  }
                ]
              }
            }
          }
        ]
      }
    ]
  },
  "id": 1
}
essentials.get_holders_countJSON-RPC

Returns the holder count for one Alkane.

This returns the aggregate count only; use the holder list endpoints when you need balances, address rows, or pagination.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_holders_count",
  "params": {
    "alkane": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "count": 6409
  },
  "id": 1
}
essentials.get_address_outpointsJSON-RPC

Lists Alkane-bearing outpoints for an address.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_address_outpoints",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "outpoints": [
      {
        "outpoint": "ee46dd269ba0f826b0dc9f78de1875fab3ab80983e51e741ffdfa6f3b7d4aef7:0",
        "entries": [
          {
            "alkane": "2:0",
            "amount": "30950001348973"
          }
        ]
      }
    ]
  },
  "id": 1
}
essentials.get_address_spendable_outpointsJSON-RPC

Returns address UTXOs that are spendable for Alkane-aware wallet flows.

These endpoints are for wallet construction flows and may include enough transaction context to build or simulate spends.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_address_spendable_outpoints",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "omit_raw_tx": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 951279,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "length": 9,
    "outpoints": [
      {
        "outpoint": "b8cb5e85a7d024fb26c85e29678a377e257dd04c0a19905de6b1d7e3cd772c14:0",
        "value": 546,
        "confirmations": 11735,
        "alkanes": {
          "2:77183": "1"
        },
        "runes": {},
        "script_pubkey_hex": "5120b819f74e24970413521ae6dcf8ec58ed4b65db6c36cbed4c8c7d95e56d4cfd4f"
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_tx_summaryJSON-RPC

Returns the indexed Alkane summary for a transaction.

Trace data explains contract execution, emitted events, and state changes. It is heavier than summary data and should be paged or scoped where possible.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_tx_summary",
  "params": {
    "txid": "a44d1f42e1eb15b779f75089cd496f61b73ef68d411d09701ebd9ea51ade7cf8"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "txid": "a44d1f42e1eb15b779f75089cd496f61b73ef68d411d09701ebd9ea51ade7cf8",
    "traces": [
      {
        "outpoint": "a44d1f42e1eb15b779f75089cd496f61b73ef68d411d09701ebd9ea51ade7cf8:3"
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_block_txsJSON-RPC

Returns Alkane transactions for a block height with paging.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_block_txs",
  "params": {
    "height": 946000,
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "page": 1,
    "limit": 1,
    "total": 39,
    "txids": [
      "5f989ae22dc2d2d178a16d88dcca3e7b92ecea6231a13b56e93b82fe3df56e4d"
    ]
  },
  "id": 1
}
essentials.get_alkane_address_txsJSON-RPC

Returns Alkane transactions involving an address.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_address_txs",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "page": 1,
    "limit": 1,
    "total": 19,
    "txids": [
      "e212e704173d61d19a280de3af2f6a5166ecf95e9a2a98f74ceeeb3de323ea1c"
    ]
  },
  "id": 1
}
essentials.get_address_transactionsJSON-RPC

Returns 比特币 transactions for an address with exact indexed block heights, Unix block times, and 次确认s, and can be narrowed to Alkane transactions. 待处理 transactions can be included from electrs REST on page 1 only. When `filter` is provided with `only_alkane_txs`, it scans Alkane transactions until the requested confirmed page is filled and returns `total: null`.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • `only_alkane_txs` defaults to true. Set it to false only when you want the full 比特币 address history instead of the Alkane transaction index.
  • `filter` accepts an Alkane id such as `2:0` and is valid only when `only_alkane_txs` is true or omitted.
  • Filtered results match Alkane transactions whose first trace event is an `invoke` where `context.myself` equals the requested Alkane id.
  • The filter is applied at request time by scanning the existing address Alkane transaction list until the requested page is filled. It does not require a new index.
  • When `filter` is provided, `total` is `null` because the filtered total is not known without scanning the complete address history. Use `has_more` for pagination.
  • `include_mempool` defaults to false. When true, all matching transactions currently returned by electrs `/address/:address/txs/mempool` are prepended to page 1 and do not consume confirmed pagination slots.
  • Mempool inclusion requires `electrs_esplora_url`. Requests with `include_mempool: true` return `unsupported_backend` when Espo is configured to use Electrum RPC instead.
  • 待处理 transactions have `confirmed: false`, `blockHeight: null`, `blockTime: null`, and `confirmations: 0`. Espo queries electrs on every included request, so dropped or RBF-replaced transactions disappear on the next poll.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_address_transactions",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "page": 1,
    "limit": 1,
    "only_alkane_txs": true,
    "filter": "2:0",
    "include_mempool": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "page": 1,
    "limit": 1,
    "include_mempool": true,
    "total": null,
    "has_more": true,
    "transactions": [
      {
        "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
        "blockHeight": null,
        "blockTime": null,
        "confirmations": 0,
        "confirmed": false
      },
      {
        "txid": "e212e704173d61d19a280de3af2f6a5166ecf95e9a2a98f74ceeeb3de323ea1c",
        "blockHeight": 939827,
        "blockTime": 1779308930,
        "confirmations": 6174,
        "confirmed": true
      }
    ]
  },
  "id": 1
}
essentials.get_alkane_latest_tracesJSON-RPC

Returns the recent Alkane trace feed used by the explorer.

Trace data explains contract execution, emitted events, and state changes. It is heavier than summary data and should be paged or scoped where possible.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_alkane_latest_traces",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "txids": [
      "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
      "4778e266cd2db0be03ebe96bb2713a2fe27d1587e4f10085f64b542f2bfd3617"
    ]
  },
  "id": 1
}
essentials.get_debug_timer_totalsJSON-RPC

Returns optional debug timer totals and can reset them when reset is true.

This is an operational endpoint intended for monitoring and debugging a running Espo node rather than user-facing portfolio state.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.get_debug_timer_totals",
  "params": {
    "limit": 20,
    "reset": false
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "reset": false,
    "reset_deleted": null,
    "timers": [
      {
        "title": "module=essentials section=update_balances",
        "kind": "section",
        "module": "essentials",
        "label": "update_balances",
        "count": 42,
        "total_ms": 84512,
        "avg_ms": 2012.19,
        "max_ms": 4110,
        "min_ms": 881,
        "last_ms": 1915
      }
    ],
    "returned": 1,
    "total_entries": 1,
    "total_ms": 84512,
    "total_calls": 42
  },
  "id": 1
}
essentials.pingJSON-RPC

Checks that the essentials module can answer RPC calls.

A successful response only proves the module handler is reachable; it does not guarantee every optional backing service is enabled.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "essentials.ping",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "pong": true
  },
  "id": 1
}

AMM Data JSON-RPC

Pool, candle, activity, price, swap routing, and AMM analytics methods.

ammdata.get_candlesJSON-RPC

Returns OHLCV candles for a pool or token pair over a supported timeframe.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_candles",
  "params": {
    "pool": "2:53014",
    "timeframe": "1h",
    "limit": 10,
    "page": 1,
    "side": "base"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "candles": [
      {
        "ts": 1710000000,
        "open": "1",
        "high": "2",
        "low": "1",
        "close": "2",
        "volume": "100"
      }
    ]
  },
  "id": 1
}
ammdata.get_btc_usd_candlesJSON-RPC

Returns Espo's native indexed BTC/USD history without deriving it through an Alkane market. Supported timeframes are 10m, 1h, 4h, 1d, 1w, and 1M. Candles are newest first and prices are fixed-point integers scaled by 10^16; divide open, high, low, and close by price_scale to obtain USD. Missing buckets are forward-filled from the last indexed price, and volume is always zero because this is a price index rather than an AMM market.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_btc_usd_candles",
  "params": {
    "timeframe": "1h",
    "limit": 2,
    "page": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "pair": "btc-usd",
    "timeframe": "1h",
    "page": 1,
    "limit": 2,
    "total": 1000,
    "has_more": true,
    "price_scale": "10000000000000000",
    "price_decimals": 16,
    "candles": [
      {
        "ts": 1779307200,
        "open": "650000000000000000000",
        "high": "650000000000000000000",
        "low": "650000000000000000000",
        "close": "650000000000000000000",
        "volume": "0"
      }
    ]
  },
  "id": 1
}
ammdata.get_alkanes_quoteJSON-RPC

Returns current and 24-hour USD quotes for BTC and requested Alkanes. frBTC (32:0) is pegged directly to Espo's indexed BTC/USD history, so its prices and changes match BTC exactly. Other Alkane quotes prefer the configured merged <token>-derived_<quote>-usd chart, fall back to the direct <token>-usd chart, and return zero prices when neither chart exists. Current prices use the latest 10-minute close and comparison prices use hourly candle index 24. change_24h is the percentage change and change_24h_usd is the absolute price change.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_alkanes_quote",
  "params": {
    "assets": [
      "btc",
      "2:0",
      "2:68479"
    ]
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "timeframe": "1h",
    "comparison_hours": 24,
    "assets": {
      "btc": {
        "name": "Bitcoin",
        "symbol": "BTC",
        "price_now_usd": "65000",
        "price_24h_ago_usd": "64000",
        "change_24h": "1.5625",
        "change_24h_usd": "1000",
        "price_now_ts": 1779307200,
        "price_24h_ago_ts": 1779220800
      },
      "2:0": {
        "name": "DIESEL",
        "symbol": "diesel",
        "price_now_usd": "0.75",
        "price_24h_ago_usd": "0.7",
        "change_24h": "7.1428",
        "change_24h_usd": "0.05",
        "price_now_ts": 1779307200,
        "price_24h_ago_ts": 1779220800
      },
      "2:68479": {
        "name": "TORTILLA",
        "symbol": "TORTILLA",
        "price_now_usd": "0",
        "price_24h_ago_usd": "0",
        "change_24h": "0.0000",
        "change_24h_usd": "0",
        "price_now_ts": null,
        "price_24h_ago_ts": null
      }
    }
  },
  "id": 1
}
ammdata.get_alkane_quoteJSON-RPC

Returns one BTC or Alkane quote using the same BTC-pegged frBTC, merged-derived, direct-USD, then zero fallback order as ammdata.get_alkanes_quote. The asset field also accepts an Alkane ID under the alkane alias.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_alkane_quote",
  "params": {
    "asset": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "2:0",
    "timeframe": "1h",
    "comparison_hours": 24,
    "name": "DIESEL",
    "symbol": "diesel",
    "price_now_usd": "0.75",
    "price_24h_ago_usd": "0.7",
    "change_24h": "7.1428",
    "change_24h_usd": "0.05",
    "price_now_ts": 1779307200,
    "price_24h_ago_ts": 1779220800
  },
  "id": 1
}
ammdata.get_portfolio_statsJSON-RPC

Values an address's confirmed BTC and Alkane balances at latest or an optional indexed height. Historical BTC balances are reconstructed from address transaction history, while BTC prices come from Espo's indexed BTC/USD candles. frBTC (32:0) uses that same BTC price history. The same selected-height balances are valued at current and 24-hour-old prices, so changes represent price movement without treating purchases, sales, or transfers as gains. change_24h is the percentage change and change_24h_usd is the corresponding portfolio USD value change. Alkane names and symbols fall back to each other when one is missing, with name-to-symbol fallbacks uppercased. complete is false when any balance lacks a required price.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_portfolio_stats",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "height": 946000,
    "complete": true,
    "unpriced_assets": [],
    "total_value_usd": "65150",
    "total_value_24h_ago_usd": "64140",
    "change_24h": "1.5746",
    "change_24h_usd": "1010",
    "assets": {
      "btc": {
        "name": "Bitcoin",
        "symbol": "BTC",
        "balance": "100000000",
        "price_now_usd": "65000",
        "price_24h_ago_usd": "64000",
        "change_24h": "1.5625",
        "change_24h_usd": "1000",
        "value_now_usd": "65000",
        "value_24h_ago_usd": "64000",
        "value_change_24h_usd": "1000"
      },
      "2:0": {
        "name": "DIESEL",
        "symbol": "diesel",
        "balance": "20000000000",
        "price_now_usd": "0.75",
        "price_24h_ago_usd": "0.7",
        "change_24h": "7.1428",
        "change_24h_usd": "0.05",
        "value_now_usd": "150",
        "value_24h_ago_usd": "140",
        "value_change_24h_usd": "10"
      }
    }
  },
  "id": 1
}
ammdata.get_token_volumeJSON-RPC

Returns raw token-side AMM volume buckets for a token. A swap contributes the amount of that token traded whether the token is the pool base asset or the quote asset.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_token_volume",
  "params": {
    "token": "2:0",
    "timeframe": "1h",
    "limit": 10,
    "page": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "token": "2:0",
    "timeframe": "1h",
    "page": 1,
    "limit": 10,
    "total": 128,
    "has_more": true,
    "newest_ts": 1779886800,
    "points": [
      {
        "ts": 1779886800,
        "volume": "11486258"
      },
      {
        "ts": 1779883200,
        "volume": "875000000"
      }
    ]
  },
  "id": 1
}
ammdata.get_chart_change_blockJSON-RPC

Returns one chart change point for a named chart at a height.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_chart_change_block",
  "params": {
    "chart": "btc_usd",
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "value": "65000"
  },
  "id": 1
}
ammdata.get_chart_changes_blockJSON-RPC

Returns all chart change points available at a height.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_chart_changes_block",
  "params": {
    "height": 951270
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "available": true,
    "height": 951270,
    "charts": {
      "2:0-usd": {
        "10m": {
          "open": "760876.3864547",
          "high": "760876.3864547",
          "low": "760876.3864547",
          "close": "760876.3864547",
          "volume": "1287761936316"
        },
        "1h": {
          "open": "760876.3864547",
          "high": "760876.3864547",
          "low": "760876.3864547",
          "close": "760876.3864547",
          "volume": "1287761936316"
        }
      }
    }
  },
  "id": 1
}
ammdata.get_activityJSON-RPC

Returns AMM activity for a pool with side, type, sort, and paging filters.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_activity",
  "params": {
    "pool": "2:53014",
    "page": 1,
    "limit": 10,
    "type": "trade",
    "sort": "timestamp",
    "dir": "desc"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 10,
    "has_more": true,
    "activity_type": "trades",
    "dir": "desc",
    "filter_side": "all",
    "activity": [
      {
        "kind": "swap",
        "txid": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "timestamp": 1779888869,
        "side": "base",
        "direction": "sell",
        "amount": "11486258",
        "base_delta": "-11486258",
        "quote_delta": "1061552883247"
      }
    ]
  },
  "id": 1
}
ammdata.get_token_activityJSON-RPC

Returns AMM and token-market activity for a token.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_token_activity",
  "params": {
    "token": "2:0",
    "page": 1,
    "limit": 10,
    "kind": "trade",
    "sort_by": "timestamp"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 10,
    "has_more": true,
    "activity_type": "all",
    "kind": null,
    "activity": [
      {
        "kind": "swap",
        "index_kind": "swap",
        "pool": "DIESEL / CH4",
        "pool_id": "2:53014",
        "txid": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "timestamp": 1779888869,
        "direction": "sell",
        "amount": "11486258",
        "base": "2:0",
        "quote": "2:16",
        "base_delta": "-11486258",
        "quote_delta": "1061552883247"
      }
    ]
  },
  "id": 1
}
ammdata.get_poolsJSON-RPC

Lists indexed AMM pools.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_pools",
  "params": {
    "page": 1,
    "limit": 20
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 20,
    "has_more": true,
    "total": 149,
    "pools": {
      "2:53014": {
        "base": "2:0",
        "quote": "2:16",
        "base_reserve": "21486066722",
        "quote_reserve": "1624687948631013",
        "source": "live"
      }
    }
  },
  "id": 1
}
ammdata.get_amm_factoriesJSON-RPC

Lists AMM factory contracts known to the indexer.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_amm_factories",
  "params": {
    "page": 1,
    "limit": 20
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 20,
    "has_more": true,
    "total": 172,
    "factories": [
      "2:50187",
      "2:50193"
    ]
  },
  "id": 1
}
ammdata.find_best_swap_pathJSON-RPC

Computes the best known swap route between two Alkanes for exact-in or exact-out flows.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.find_best_swap_path",
  "params": {
    "mode": "exact_in",
    "token_in": "2:0",
    "token_out": "2:16",
    "amount_in": "100000000",
    "fee_bps": 30,
    "max_hops": 3
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "mode": "exact_in",
    "token_in": "2:0",
    "token_out": "2:16",
    "amount_in": "1000000",
    "amount_out": "89019369508",
    "fee_bps": 30,
    "max_hops": 3,
    "hops": [
      {
        "pool": "2:53014",
        "token_in": "2:0",
        "token_out": "2:16",
        "amount_in": "1000000",
        "amount_out": "75445130234"
      }
    ]
  },
  "id": 1
}
ammdata.get_best_mev_swapJSON-RPC

Returns the best detected MEV-style swap opportunity for a token under the routing constraints.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_best_mev_swap",
  "params": {
    "token": "2:0",
    "fee_bps": 30,
    "max_hops": 3
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "swap": null
  },
  "id": 1
}
ammdata.get_btc_usd_priceJSON-RPC

Returns the BTC/USD price at latest or at a requested height. price is a fixed-point integer scaled by 10^16.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_btc_usd_price",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "price": "650000000000000000000",
    "source": "ammdata_index"
  },
  "id": 1
}
ammdata.get_total_volume_ammJSON-RPC

Returns total AMM volume over a height range or preset range.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_total_volume_amm",
  "params": {
    "unit": "usd",
    "from_height": 945900,
    "to_height": 946000,
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "page": 1,
    "limit": 10,
    "range_min": 951000,
    "range_max": 951279,
    "scale": "10000000000000000",
    "latest": {
      "height": 951279,
      "value": "64040138676553303341511"
    },
    "points": [
      {
        "height": 951000,
        "value": "64024572352483080490211"
      }
    ]
  },
  "id": 1
}
ammdata.get_token_total_volumeJSON-RPC

Returns the cumulative raw AMM amount traded for one token, keyed by block height. The latest value is the all-time token-side AMM volume recorded by the index.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.get_token_total_volume",
  "params": {
    "token": "2:0",
    "from_height": 951000,
    "to_height": 951279,
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "token": "2:0",
    "page": 1,
    "limit": 10,
    "range_min": 951000,
    "range_max": 951279,
    "latest": {
      "height": 951279,
      "value": "2381492765411"
    },
    "points": [
      {
        "height": 951000,
        "value": "2367000000000"
      },
      {
        "height": 951001,
        "value": "2368123456789"
      }
    ]
  },
  "id": 1
}
ammdata.pingJSON-RPC

Checks that the AMM data module can answer RPC calls.

A successful response only proves the module handler is reachable; it does not guarantee every optional backing service is enabled.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ammdata.ping",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "pong": true
  },
  "id": 1
}

Runes JSON-RPC

Runes metadata, balances, outpoints, transaction IO, activity, and transaction index methods. These are available when the runes module is enabled.

runes.get_runeJSON-RPC

Looks up a Rune by id, spaced name, or accepted query alias.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_rune",
  "params": {
    "rune": "1:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "rune": {
      "id": "1:0",
      "spaced_name": "UNCOMMON GOODS"
    }
  },
  "id": 1
}
runes.get_top_runesJSON-RPC

Lists top Runes by holder count.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_top_runes",
  "params": {
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "runes": [
      {
        "id": "1:0",
        "number": 0,
        "rune": "UNCOMMONGOODS",
        "spaced_rune": "UNCOMMON GOODS",
        "symbol": "G",
        "divisibility": 0,
        "supply": "105594793",
        "mints": "105594793",
        "holders": 249173,
        "turbo": true
      }
    ]
  },
  "id": 1
}
runes.get_holdersJSON-RPC

Returns holders for one Rune.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_holders",
  "params": {
    "id": "1:0",
    "page": 1,
    "limit": 1
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "holders": [
      {
        "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
        "amount": "2079397"
      }
    ]
  },
  "id": 1
}
runes.get_address_balancesJSON-RPC

Returns Rune balances held by an address, optionally including outpoint rows.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
  • Including outpoints returns larger payloads and is intended for wallet or account-detail views.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_address_balances",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "include_outpoints": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "balances": {
      "1:0": "2079397",
      "840000:2": "91000000"
    },
    "items": [
      {
        "id": "1:0",
        "rune": "UNCOMMON GOODS",
        "amount": "2079397"
      }
    ],
    "outpoints": [
      {
        "outpoint": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2:1",
        "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
        "entries": [
          {
            "id": "1:0",
            "rune": "UNCOMMON GOODS",
            "amount": "2079397"
          }
        ]
      }
    ]
  },
  "id": 1
}
runes.get_address_outpointsJSON-RPC

Lists Rune-bearing outpoints for an address.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_address_outpoints",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "outpoints": [
      {
        "outpoint": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2:1",
        "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
        "entries": [
          {
            "id": "1:0",
            "rune": "UNCOMMON GOODS",
            "amount": "2079397"
          }
        ]
      }
    ]
  },
  "id": 1
}
runes.get_outpoint_balancesJSON-RPC

Returns Rune balances assigned to a specific outpoint.

Outpoint-level responses are the most precise way to understand which UTXOs carry token state before constructing a transaction.

What to know
  • Outpoints use `<txid>:<vout>`, where `vout` is the zero-based output index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_outpoint_balances",
  "params": {
    "outpoint": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2:1"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "outpoint": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2:1",
    "items": [
      {
        "outpoint": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2:1",
        "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
        "entries": [
          {
            "id": "1:0",
            "rune": "UNCOMMON GOODS",
            "amount": "2079397"
          }
        ]
      }
    ]
  },
  "id": 1
}
runes.get_tx_ioJSON-RPC

Returns Rune inputs, outputs, burns, mints, and etched Rune data for a transaction.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_tx_io",
  "params": {
    "txid": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "txid": "d11e7d18e03850c08bebaf0a9926288a4963d91b6ebcc40f8615a16ed81d40c2",
    "io": {
      "inputs": {},
      "outputs": {
        "1": {
          "1:0": "1"
        }
      },
      "minted": [
        {
          "id": "1:0",
          "amount": "1"
        }
      ],
      "etched": null
    }
  },
  "id": 1
}
runes.get_mint_activityJSON-RPC

Returns mint activity for one Rune.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_mint_activity",
  "params": {
    "id": "1:0",
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "activity": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "amount": "1",
        "destination": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
        "fee_paid_sats": 192
      }
    ]
  },
  "id": 1
}
runes.get_activityJSON-RPC

Returns paged Rune activity with kind, scope, sort, address, and time filters.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_activity",
  "params": {
    "id": "1:0",
    "page": 1,
    "limit": 10,
    "kind": "mint"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "total": 105594794,
    "entries": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "kind": "mint",
        "id": "1:0",
        "amount": "1",
        "destination": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta"
      }
    ]
  },
  "id": 1
}
runes.get_rune_activityJSON-RPC

Alias-style Rune activity endpoint with the same filters as runes.get_activity.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_rune_activity",
  "params": {
    "rune": "1:0",
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "total": 105594794,
    "activity": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "kind": "mint",
        "amount": "1"
      }
    ],
    "entries": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "kind": "mint",
        "amount": "1"
      }
    ]
  },
  "id": 1
}
runes.get_address_activityJSON-RPC

Returns Rune activity for an address and optionally for a single Rune.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_address_activity",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "id": "all",
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "total": 1,
    "activity": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "kind": "mint",
        "id": "1:0",
        "amount": "1"
      }
    ],
    "entries": [
      {
        "height": 840113,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "kind": "mint",
        "id": "1:0",
        "amount": "1"
      }
    ]
  },
  "id": 1
}
runes.get_block_tx_countJSON-RPC

Returns the number of Rune transactions indexed for a block.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_block_tx_count",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "count": 12
  },
  "id": 1
}
runes.get_block_txsJSON-RPC

Returns a range of Rune transaction pointers for a block.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_block_txs",
  "params": {
    "height": 946000,
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "txs": [
      {
        "height": 946000,
        "tx_index": 235,
        "txid": "2d70c5d4d4d7a77551cbbd3225542ea167984a28e7bb13bc143546705ac76da6",
        "io": {
          "outputs": {
            "1": {
              "1:0": "1"
            }
          }
        }
      }
    ]
  },
  "id": 1
}
runes.get_address_tx_countJSON-RPC

Returns the number of Rune transactions indexed for an address.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_address_tx_count",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "count": 48
  },
  "id": 1
}
runes.get_address_txsJSON-RPC

Returns a range of Rune transaction pointers for an address.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_address_txs",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "page": 1,
    "limit": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "txs": [
      {
        "height": 840113,
        "tx_index": 465,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2"
      }
    ]
  },
  "id": 1
}
runes.get_action_block_tx_countJSON-RPC

Returns the number of Rune action transactions indexed for a block.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_action_block_tx_count",
  "params": {
    "height": 946000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "count": 3
  },
  "id": 1
}
runes.get_action_block_txsJSON-RPC

Returns Rune action transaction pointers for a block.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_action_block_txs",
  "params": {
    "height": 946000,
    "start": 0,
    "end": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "height": 946000,
    "txs": [
      {
        "height": 946000,
        "tx_index": 235,
        "txid": "2d70c5d4d4d7a77551cbbd3225542ea167984a28e7bb13bc143546705ac76da6",
        "has_rune": true,
        "has_alkane": false
      }
    ]
  },
  "id": 1
}
runes.get_action_address_tx_countJSON-RPC

Returns the number of Rune action transactions indexed for an address.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_action_address_tx_count",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "count": 65
  },
  "id": 1
}
runes.get_action_address_txsJSON-RPC

Returns Rune action transaction pointers for an address.

Rune endpoints are available only when the runes module is enabled and follow the Rune id and spaced-name conventions used by the indexer.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runes.get_action_address_txs",
  "params": {
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "start": 0,
    "end": 10
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pc8sn4zzfessnglpvy8mj27z0jkgp3j6ra2l7w3rpjcatf84mhdeqtlveta",
    "txs": [
      {
        "height": 840113,
        "tx_index": 465,
        "txid": "c0ace2bc013a2ea764143aabd41333590cb2ce3db8885c6467e50868143c5cc2",
        "has_rune": true
      }
    ]
  },
  "id": 1
}

Token Data JSON-RPC

Token activity views combining mint and AMM sources with time and sort filters.

tokendata.get_token_activityJSON-RPC

Returns token activity for one Alkane across market and mint sources. 市场 reads can be filtered to a canonical quote pool with a minimum quote-side amount.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • Time filters are Unix timestamps in seconds.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
  • `canonical_quote`/`quote` filters token activity to rows whose counter token is that Alkane id. `min_quote_amount`/`min_amount` is a raw 1e8-scaled token amount, such as `100000` for 0.001 frBTC.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tokendata.get_token_activity",
  "params": {
    "token": "2:68479",
    "page": 1,
    "limit": 10,
    "from": 1700000000,
    "to": 1800000000,
    "filter": "market",
    "sort_by": "timestamp",
    "dir": "desc",
    "canonical_quote": "32:0",
    "min_quote_amount": "100000"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "total": 11,
    "entries": [
      {
        "kind": "buy",
        "source": "market",
        "height": 951279,
        "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
        "token": "2:68479",
        "pool": "2:90001",
        "counter_token": "32:0",
        "token_delta": "250000000000",
        "counter_delta": "-100000",
        "chain_txids": [
          "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90"
        ],
        "success": true
      }
    ]
  },
  "id": 1
}
tokendata.get_address_activityJSON-RPC

Returns token activity for one address, optionally filtered to a token.

Activity rows are normalized event views intended for timelines. For exact wallet spendability, combine them with balance or outpoint endpoints.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • Time filters are Unix timestamps in seconds.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tokendata.get_address_activity",
  "params": {
    "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
    "token": "all",
    "page": 1,
    "limit": 10,
    "from": 1700000000,
    "to": 1800000000
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "total": 1,
    "entries": [
      {
        "kind": "mint",
        "height": 951279,
        "txid": "f390179d0a4586016c834a972abde346f1f0f095e3876513a5c96b8a93194f90",
        "token": "2:0",
        "amount": "1000000",
        "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
      }
    ]
  },
  "id": 1
}

Pizza.fun JSON-RPC

Pizza.fun series id to Alkane id lookup methods.

pizzafun.get_series_id_from_alkane_idJSON-RPC

Resolves a Pizza.fun series id from a single Alkane id.

Pizza.fun mapping methods bridge off-explorer series identifiers with Alkane ids; null batch entries mean no confirmed mapping was found.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "pizzafun.get_series_id_from_alkane_id",
  "params": {
    "alkane_id": "2:0"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "series_id": "diesel",
    "alkane_id": "2:0",
    "confirmations": 100
  },
  "id": 1
}
pizzafun.get_series_ids_from_alkane_idsJSON-RPC

Batch resolves Pizza.fun series ids from Alkane ids.

Pizza.fun mapping methods bridge off-explorer series identifiers with Alkane ids; null batch entries mean no confirmed mapping was found.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "pizzafun.get_series_ids_from_alkane_ids",
  "params": {
    "alkane_ids": [
      "2:0",
      "2:77578"
    ]
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "items": [
      {
        "series_id": "diesel",
        "alkane_id": "2:0"
      },
      {
        "series_id": "wai",
        "alkane_id": "2:77578"
      }
    ]
  },
  "id": 1
}
pizzafun.get_alkane_id_from_series_idJSON-RPC

Resolves an Alkane id from a single Pizza.fun series id.

Pizza.fun mapping methods bridge off-explorer series identifiers with Alkane ids; null batch entries mean no confirmed mapping was found.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "pizzafun.get_alkane_id_from_series_id",
  "params": {
    "series_id": "diesel"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "series_id": "diesel",
    "alkane_id": "2:0",
    "confirmations": 100
  },
  "id": 1
}
pizzafun.get_alkane_ids_from_series_idsJSON-RPC

Batch resolves Alkane ids from Pizza.fun series ids.

Pizza.fun mapping methods bridge off-explorer series identifiers with Alkane ids; null batch entries mean no confirmed mapping was found.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "pizzafun.get_alkane_ids_from_series_ids",
  "params": {
    "series_ids": [
      "diesel",
      "wai"
    ]
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "items": [
      {
        "series_id": "diesel",
        "alkane_id": "2:0"
      },
      {
        "series_id": "wai",
        "alkane_id": "2:77578"
      }
    ]
  },
  "id": 1
}

Subfrost JSON-RPC

Current frBTC signer and wrap and unwrap event and request history methods.

subfrost.get_signerJSON-RPC

Returns the current Subfrost signer address from the indexed /signer scriptPubKey on frBTC contract 32:0.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_signer",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "alkane": "32:0",
    "storage_key": "/signer",
    "script_pubkey": "0x51201d4830313fb48f68b43b07391fe1232f8488621b2cbc5fb4b26d8935e4bf1cb4",
    "address": "bcrt1pr4yrqvflkj8k3dpmquu3lcfr97zgscsm9j79ld9jdkynte9lrj6qlcsdcx"
  },
  "id": 1
}
subfrost.get_wrap_events_by_addressJSON-RPC

Returns frBTC wrap events for an address.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_wrap_events_by_address",
  "params": {
    "address": "bc1p9qftzwgufdv5h7zk674jvppfjfa9eys56zzflfvvrg4cekpwfy9s3yerpx",
    "count": 10,
    "offset": 0,
    "successful": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "txid": "7edddf6ee5f6e39e503a8c9c7f80ff27285e2da37b61d6728b40f5903f316f36",
        "amount": "100000",
        "success": true,
        "timestamp": 1779308930,
        "address_spk": "51202aabf8f66f109d8a79e0c922d769bb5b31a85ecaf35920aa8b3d16c1f032c155"
      }
    ],
    "total": 3565
  },
  "id": 1
}
subfrost.get_unwrap_events_by_addressJSON-RPC

Returns frBTC unwrap events for an address.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_unwrap_events_by_address",
  "params": {
    "address": "bc1q2l9yryzdq82pteuhrjt93cuvgazr5ph8z5zgqw",
    "count": 10,
    "offset": 0
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "txid": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "amount": "100000",
        "success": true,
        "timestamp": 1779285102,
        "address_spk": "001457ca41904d01d415e7971c9658e38c47443a06e7"
      }
    ],
    "total": 2339
  },
  "id": 1
}
subfrost.get_wrap_events_allJSON-RPC

Returns global frBTC wrap events.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_wrap_events_all",
  "params": {
    "count": 10,
    "offset": 0,
    "successful": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "txid": "7edddf6ee5f6e39e503a8c9c7f80ff27285e2da37b61d6728b40f5903f316f36",
        "amount": "100000",
        "success": true,
        "timestamp": 1779308930,
        "address_spk": "51202aabf8f66f109d8a79e0c922d769bb5b31a85ecaf35920aa8b3d16c1f032c155"
      }
    ],
    "total": 3565
  },
  "id": 1
}
subfrost.get_unwrap_events_allJSON-RPC

Returns global frBTC unwrap events.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_unwrap_events_all",
  "params": {
    "count": 10,
    "offset": 0
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "txid": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "amount": "100000",
        "success": true,
        "timestamp": 1779285102,
        "address_spk": "001457ca41904d01d415e7971c9658e38c47443a06e7"
      }
    ],
    "total": 2339
  },
  "id": 1
}
subfrost.get_unwrap_requests_by_addressJSON-RPC

Returns unwrap requests for an address, optionally filtered by fulfillment state.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `fulfilled` separates requested unwraps from requests that have completed their fulfillment flow.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_unwrap_requests_by_address",
  "params": {
    "address": "bc1q2l9yryzdq82pteuhrjt93cuvgazr5ph8z5zgqw",
    "count": 10,
    "offset": 0,
    "fulfilled": false
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "request_txid": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "amount": "100000",
        "fulfilled": false,
        "timestamp": 1779285102,
        "address_spk": "001457ca41904d01d415e7971c9658e38c47443a06e7"
      }
    ],
    "total": 1
  },
  "id": 1
}
subfrost.get_unwrap_requests_allJSON-RPC

Returns global unwrap requests, optionally filtered by fulfillment state.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • `fulfilled` separates requested unwraps from requests that have completed their fulfillment flow.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "subfrost.get_unwrap_requests_all",
  "params": {
    "count": 10,
    "offset": 0,
    "fulfilled": false
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "items": [
      {
        "request_txid": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "amount": "100000",
        "fulfilled": false,
        "timestamp": 1779285102,
        "address_spk": "001457ca41904d01d415e7971c9658e38c47443a06e7"
      }
    ],
    "total": 1
  },
  "id": 1
}

Counterparty JSON-RPC

Thin Counterparty overlay. Espo does not re-index the XCP ledger; xcp.get_tx, xcp.get_asset, xcp.get_address_balances, xcp.get_asset_dispenses, and xcp.get_asset_market read a local Counterparty Core API and the explorer also RC4-decodes classic OP_RETURN payloads.

xcp.get_txJSON-RPC

Returns Counterparty Core data plus a normalized explorer view for one 比特币 transaction. The view is optional overlay data: a tx can also carry Alkanes or Runes. Fail-open when Core is unreachable.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_tx",
  "params": {
    "txid": "6000542810cfa82b1d8ca767139cc71307d9d64348befcc2b0df2f241771500b"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "txid": "6000542810cfa82b1d8ca767139cc71307d9d64348befcc2b0df2f241771500b",
    "view": {
      "headline": "112 XCP bought from a dispenser for 0.00615888 BTC",
      "actions": [
        {
          "method": "dispense",
          "headline": "112 XCP bought from a dispenser for 0.00615888 BTC",
          "asset": "XCP",
          "amount": "112",
          "rate_btc": "0.00005499",
          "btc_total": "0.00615888",
          "status": "Settled",
          "buyer": "bc1pwufsn2zc63ttglsngtdyud4lyp9q23u44z3cjqe9yj8wllfq702qhp4dj9",
          "seller": "1DGaau3xBytkfXxgaKcoa7GRmitdfoV7hu",
          "dispenser_tx": "462c8c9c3ccd3fd2f234febf3c359e7ab935c0e0fba7ffee62eeeeb1321a9321",
          "machine_closed": true
        }
      ],
      "transfers": [
        {
          "address": "1DGaau3xBytkfXxgaKcoa7GRmitdfoV7hu",
          "asset": "XCP",
          "amount": "112",
          "incoming": false
        },
        {
          "address": "bc1pwufsn2zc63ttglsngtdyud4lyp9q23u44z3cjqe9yj8wllfq702qhp4dj9",
          "asset": "XCP",
          "amount": "112",
          "incoming": true
        }
      ]
    }
  },
  "id": 1
}
xcp.get_assetJSON-RPC

Resolves a Counterparty asset by name, numeric id, or A-prefixed id and returns the Core asset object plus a holders count. Fail-open when Core is unreachable. The explorer page is /counterparty/asset/{asset}.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset",
  "params": {
    "asset": "XCP"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "XCP",
    "holders": 45414,
    "result": {
      "asset": "XCP",
      "divisible": true,
      "locked": true,
      "supply": 258692531471873,
      "supply_normalized": "2586925.31471873",
      "description": "The Counterparty protocol native currency"
    }
  },
  "id": 1
}
xcp.get_address_balancesJSON-RPC

Returns non-zero Counterparty asset balances for a 比特币 address, including taproot. XCP is first, then remaining assets by quantity. Optional asset limits the result to one name. Fail-open when Core is unreachable. The explorer page is /address/{address}.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_address_balances",
  "params": {
    "address": "bc1pwufsn2zc63ttglsngtdyud4lyp9q23u44z3cjqe9yj8wllfq702qhp4dj9"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "address": "bc1pwufsn2zc63ttglsngtdyud4lyp9q23u44z3cjqe9yj8wllfq702qhp4dj9",
    "balances": {
      "XCP": "1312.00000000"
    },
    "items": [
      {
        "asset": "XCP",
        "asset_longname": null,
        "quantity": "131200000000",
        "quantity_normalized": "1312.00000000",
        "divisible": true
      }
    ]
  },
  "id": 1
}
xcp.get_asset_dispensesJSON-RPC

Newest confirmed BTC dispenses for a Counterparty asset, newest block first. Used for last-sale prices such as XCP. Fail-open when Core is unreachable.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset_dispenses",
  "params": {
    "asset": "XCP",
    "limit": 5
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "XCP",
    "result_count": 1,
    "result": [
      {
        "asset": "XCP",
        "dispense_quantity_normalized": "6",
        "btc_amount_normalized": "0.000579",
        "block_index": 965540
      }
    ]
  },
  "id": 1
}
xcp.get_asset_historyJSON-RPC

Paginated native Counterparty records with all original verbose fields, message indexes, normalized quantities, statuses and transaction references. Types: issuances, sends (including enhanced/MPMA/UTXO send types), dispensers, dispenses, orders, matches, dividends, destructions, subassets, fairminters, fairmints, credits, debits, pool_matches, pool_deposits, pool_withdrawals, pool_history. Pool routes accept quote_asset (default XCP). Status defaults to all; orders: open/filled/cancelled/expired; matches: completed/pending/expired; dispensers: open/closing/closed/open_empty_address. Limit 1..200 (default 50), offset 0..10000000. Total is the node total; result_count is this page. Unsupported/unreachable routes return ok:false, never a fabricated empty success. Non-pool routes use node-native history order, explicitly newest block first where supported.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset_history",
  "params": {
    "asset": "DJPEPE",
    "type": "orders",
    "status": "all",
    "offset": 0,
    "limit": 50
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "DJPEPE",
    "type": "orders",
    "status": "all",
    "quote_asset": "XCP",
    "offset": 0,
    "limit": 50,
    "total": 323,
    "result_count": 1,
    "has_more": true,
    "result": [
      {
        "status": "cancelled",
        "give_asset": "XCP",
        "give_quantity_normalized": "400.00000000",
        "get_asset": "DJPEPE",
        "get_quantity_normalized": "1"
      }
    ]
  },
  "id": 1
}
xcp.get_asset_activityJSON-RPC

Recent unified activity: all, trades, sends, dispenses, issuances, orders, dispensers, dividends, destructions, fairminters, fairmints, credits, debits, pool_deposits or pool_withdrawals. All/trades are a newest-250-record window (offset below 250); use get_asset_history for unrestricted native pagination. Limit 1..200. Each record preserves the original message, so several sends/fills in one transaction remain separate. Orders and dispensers are current-state records dated by the node-reported block, not a complete status-change timeline; credits/debits expose ledger actions such as cancellations and refunds. A failed source returns ok:false rather than silently dropping data.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset_activity",
  "params": {
    "asset": "DJPEPE",
    "type": "all",
    "offset": 0,
    "limit": 50
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "DJPEPE",
    "type": "all",
    "offset": 0,
    "limit": 50,
    "total": 250,
    "recent_window": 250,
    "has_more": true,
    "result": [
      {
        "action": "Orders",
        "block_index": 959105,
        "block_time": 1784702010,
        "tx_hash": "85e7a7afd1ac0d1346305dc7dd58a20c4f92cdba15fe9fdd04c9415908f0c985",
        "record": {
          "status": "cancelled"
        }
      }
    ]
  },
  "id": 1
}
xcp.get_asset_marketJSON-RPC

Latest observed XCP/BTC trade price across pool, completed DEX matches and BTC dispenses, with a reserve spot fallback. The summary adds original-currency volumes (including non-XCP/BTC quotes), last trades by currency, best open DEX bids/asks, escrow, open order/dispenser counts, resolved dispenser BTC floor and active months. Summary cache: 60 seconds; at most 2000 rows per source. Inspect complete, trade_history_complete, listings_complete and sources before treating aggregates as lifetime totals. Sources: completed matches, dispenses, asset/XCP pool swaps, open orders and open dispensers. Price calculations are display estimates. No historical USD conversion or off-chain trades; XCP/BTC conversion is an indicative last-dispense rate. Other AMM pairs are available through get_asset_history. Existing top-level price fields remain available; summary volumes keep currencies separate.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset_market",
  "params": {
    "asset": "MSGA"
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "asset": "MSGA",
    "quote_asset": "XCP",
    "price": "0.00002039",
    "price_btc": "0.000000002243",
    "price_sats": 0,
    "icon": "https://xcp.fun/icon/MSGA",
    "spot": {
      "quote_asset": "XCP",
      "price": "0.00002044216596",
      "reserve_base": "32895186.37312087",
      "reserve_quote": "672.44885897"
    },
    "last_trade": {
      "venue": "pool",
      "side": "sell",
      "quote_asset": "XCP",
      "price": "0.00002039",
      "base_amount": "245192.64660789",
      "quote_amount": "5",
      "block_index": 965410
    },
    "summary": {
      "complete": true,
      "trade_history_complete": true,
      "listings_complete": true,
      "open_orders": 3,
      "open_dispensers": 0,
      "order_escrow": "3",
      "volumes": [
        {
          "quote_asset": "XCP",
          "asset_quantity": "2",
          "quote_quantity": "8200",
          "trades": 2
        }
      ],
      "best_asks": [
        {
          "quote_asset": "XCP",
          "price": "4100"
        }
      ],
      "sources": [
        {
          "type": "matches",
          "status": "completed",
          "total": 2,
          "loaded": 2,
          "complete": true
        }
      ]
    },
    "venues": {
      "pool_matches": 44,
      "dex_matches": 2,
      "dispenses": 0
    }
  },
  "id": 1
}

Counterparty unit numbering

Read-only access to the independent XCP history service. The complete method explanation is /counterparty/numbering. The worker has its own database and checkpoint; it never causes an Alkanes resync. All data methods return context with network, ruleset, source commit, phase, completeness and numbering height/hash. By default incomplete or stale data is an error; allow_partial:true explicitly selects the reported historical checkpoint. verified is false until the separate legacy and live audit gates are complete. Serials, range endpoints and quantities are decimal strings. Cursors are tied to the exact projection generation and query; stale_cursor requires restarting pagination. Limit 1..200. Histories may return an empty filtered page with has_more:true because scans are bounded. Typed locations distinguish addresses, UTXOs, orders, pending BTC matches, dispensers, pool reserves, fairmint escrow, retired and destroyed units.

xcp.get_numbering_statusJSON-RPC

Returns archive download progress, validated archive tip, numbering tip, freshness, source adapter identity and pause diagnostics. A successful status response does not imply complete numbering. No parameters. The worker's private GET /status returns the same status shape; private POST /query accepts {method,params} without the xcp. prefix and is loopback-only.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_numbering_status",
  "params": {}
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "network": "mainnet",
    "ruleset": "nakamoto-stack-v1",
    "phase": "downloading_history",
    "complete": false,
    "verified": false,
    "numbering_tip": null,
    "archive_tip": null,
    "download": {
      "downloaded_events": 1000
    }
  },
  "id": 1
}
xcp.get_asset_unitsJSON-RPC

Returns paginated current directed serial ranges for a canonical asset or alias. asset is required. Optional limit, cursor and allow_partial. Range order is by lowest serial; stack_position is the zero-based position of this directed run in its location's ordered stack. Never sort a holder's units by serial to infer transfer order. This endpoint includes escrow and terminal locations.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_asset_units",
  "params": {
    "asset": "RAREPEPE",
    "limit": 20,
    "allow_partial": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "context": {
      "ruleset": "nakamoto-stack-v1",
      "complete": false,
      "numbering_tip": {
        "height": 725934
      }
    },
    "asset": "RAREPEPE",
    "items": [
      {
        "asset": "RAREPEPE",
        "location": {
          "kind": "address",
          "id": "1Example",
          "controller": "1Example"
        },
        "range": {
          "first": "5",
          "last": "3",
          "quantity": "3"
        },
        "stack_position": "0"
      }
    ],
    "has_more": false,
    "next_cursor": null
  },
  "id": 1
}
xcp.get_unitJSON-RPC

Looks up one serial at the reported checkpoint, including UTXO, escrow, retired or destroyed locations. asset and serial are required; serial is a positive decimal string. Optional allow_partial. No fabricated owner is returned for units not issued at the checkpoint. Issuance rights and controller addresses are separate from unit locations.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_unit",
  "params": {
    "asset": "RAREPEPE",
    "serial": "1",
    "allow_partial": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "context": {
      "ruleset": "nakamoto-stack-v1",
      "complete": false
    },
    "asset": "RAREPEPE",
    "serial": "1",
    "location": {
      "kind": "utxo",
      "id": "txid:0",
      "controller": "bc1example"
    }
  },
  "id": 1
}
xcp.get_unit_historyJSON-RPC

Returns issuance and movement legs containing one serial, oldest first, with event indexes and nullable transaction hashes. asset and serial required; optional limit, cursor and allow_partial. A movement's ranges include the requested serial and may include other units that moved with it. Several legs in a transaction remain distinct. System events need not have a transaction hash; event_reference preserves the Core operation reference, including older transactions or match IDs.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_unit_history",
  "params": {
    "asset": "RAREPEPE",
    "serial": "1",
    "limit": 50,
    "allow_partial": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "context": {
      "ruleset": "nakamoto-stack-v1",
      "complete": false
    },
    "items": [
      {
        "asset": "RAREPEPE",
        "block": 428919,
        "event_index": "3378670",
        "leg": 0,
        "tx_hash": null,
        "reason": "issuance",
        "from": null,
        "to": {
          "kind": "address",
          "id": "1Example"
        },
        "ranges": [
          {
            "first": "1",
            "last": "300",
            "quantity": "300"
          }
        ]
      }
    ],
    "has_more": false,
    "next_cursor": null
  },
  "id": 1
}
xcp.get_address_unitsJSON-RPC

Returns numbered ranges at locations controlled by an address, including its wrapped UTXOs and order/dispenser escrow. address required; optional asset, limit, cursor and allow_partial. A pool's LP holder is not assigned ownership of specific reserve units. This endpoint reports controller association, not just a spendable address balance; inspect location.kind.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_address_units",
  "params": {
    "address": "1Example",
    "asset": "RAREPEPE",
    "limit": 50,
    "allow_partial": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "context": {
      "ruleset": "nakamoto-stack-v1",
      "complete": false
    },
    "items": [
      {
        "asset": "RAREPEPE",
        "location": {
          "kind": "order",
          "id": "order_txid",
          "controller": "1Example"
        },
        "range": {
          "first": "300",
          "last": "151",
          "quantity": "150"
        },
        "stack_position": "0"
      }
    ],
    "has_more": false,
    "next_cursor": null
  },
  "id": 1
}
xcp.get_transfer_unitsJSON-RPC

Returns all numbered movement ranges associated with a transaction, ordered by event index and leg. txid is required (64 hexadecimal characters); optional asset, limit, cursor and allow_partial. Does not deduplicate by transaction hash. Includes later block actions whose event_reference is this transaction. tx_hash is the current transaction when present; event_reference retains the source operation reference.

Counterparty data is read from a local Core API. The explorer also RC4-decodes classic OP_RETURN payloads; Core supplies assets, quantities, and events that the OP_RETURN does not carry.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "xcp.get_transfer_units",
  "params": {
    "txid": "4c9d2979685dc172864a5c00811f44034e7966bc6555dcc272531c4bdd304405",
    "asset": "RAREPEPE",
    "allow_partial": true
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "context": {
      "ruleset": "nakamoto-stack-v1",
      "complete": false
    },
    "items": [
      {
        "asset": "RAREPEPE",
        "block": 428919,
        "event_index": "3378670",
        "leg": 0,
        "reason": "issuance",
        "from": null,
        "to": {
          "kind": "address",
          "id": "1Example"
        },
        "ranges": [
          {
            "first": "1",
            "last": "300",
            "quantity": "300"
          }
        ]
      }
    ],
    "has_more": false,
    "next_cursor": null
  },
  "id": 1
}

Oyl-Compatible HTTP API

POST endpoints served by the oylapi module for wallet and AMM clients.

/get-alkanes-by-addressPOST

Returns Alkane balances and metadata for a 比特币 address.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-alkanes-by-address
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
}
Example response
{
  "statusCode": 200,
  "data": [
    {
      "alkaneId": {
        "block": "2",
        "tx": "0"
      },
      "name": "DIESEL",
      "symbol": "DIESEL",
      "balance": "26064398814169",
      "priceInSatoshi": "10927011166337",
      "floorPrice": 82.07730465298008
    }
  ]
}
/get-bitcoin-pricePOST

Returns the cached BTC/USD price used by Oyl-compatible responses.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

Example query
POST https://api.alkanode.com/get-bitcoin-price
{}
Example response
{
  "price": "65000"
}
/get-alkanes-utxoPOST

Returns Alkane UTXOs for an address.

Outpoint-level responses are the most precise way to understand which UTXOs carry token state before constructing a transaction.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-alkanes-utxo
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8"
}
Example response
{
  "statusCode": 200,
  "data": [
    {
      "txId": "b8cb5e85a7d024fb26c85e29678a377e257dd04c0a19905de6b1d7e3cd772c14",
      "outputIndex": 0,
      "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
      "satoshis": 546,
      "confirmations": 11735,
      "indexed": true,
      "alkanes": {
        "2:77183": "1"
      },
      "runes": {}
    }
  ]
}
/get-address-utxosPOST

Returns portfolio UTXOs for an address with optional spend strategy filtering.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `spendStrategy` is passed through to wallet-style UTXO selection. Use `null` or omit it for the route default.
Example query
POST https://api.alkanode.com/get-address-utxos
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
  "spendStrategy": null
}
Example response
{
  "statusCode": 200,
  "data": {
    "total余额": 244280,
    "spendableTotal余额": 239912,
    "pendingTotal余额": 0,
    "alkaneUtxos": [
      {
        "txId": "b8cb5e85a7d024fb26c85e29678a377e257dd04c0a19905de6b1d7e3cd772c14",
        "outputIndex": 0,
        "satoshis": 546,
        "alkanes": {
          "2:77183": "1"
        }
      }
    ],
    "spendableUtxos": [
      {
        "txId": "b7d8b76bec7b9a703cbd39b311e7edb6ed0951c1c856fcbe6581396247d9afcf",
        "outputIndex": 1,
        "satoshis": 239912
      }
    ]
  }
}
/get-account-utxosPOST

Alias of get-address-utxos for clients that use account terminology.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `spendStrategy` is passed through to wallet-style UTXO selection. Use `null` or omit it for the route default.
Example query
POST https://api.alkanode.com/get-account-utxos
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
  "spendStrategy": null
}
Example response
{
  "statusCode": 200,
  "data": {
    "total余额": 244280,
    "spendableTotal余额": 239912,
    "alkaneUtxos": [
      {
        "txId": "b8cb5e85a7d024fb26c85e29678a377e257dd04c0a19905de6b1d7e3cd772c14",
        "outputIndex": 0,
        "satoshis": 546,
        "alkanes": {
          "2:77183": "1"
        }
      }
    ]
  }
}
/get-amm-utxosPOST

Returns UTXOs suitable for AMM transactions for an address.

Outpoint-level responses are the most precise way to understand which UTXOs carry token state before constructing a transaction.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `spendStrategy` is passed through to wallet-style UTXO selection. Use `null` or omit it for the route default.
Example query
POST https://api.alkanode.com/get-amm-utxos
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
  "spendStrategy": null
}
Example response
{
  "statusCode": 200,
  "data": {
    "utxos": [
      {
        "txId": "b8cb5e85a7d024fb26c85e29678a377e257dd04c0a19905de6b1d7e3cd772c14",
        "outputIndex": 0,
        "satoshis": 546,
        "confirmations": 11735,
        "alkanes": {
          "2:77183": "1"
        }
      }
    ]
  }
}
/get-alkanesPOST

Lists Alkanes with pagination, sorting, and optional search query.

These list and search methods are designed for discovery screens. They return indexed metadata, not live contract execution results.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • 搜索 text is matched against indexed token or pool metadata and may be capped by module search limits.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
Example query
POST https://api.alkanode.com/get-alkanes
{
  "limit": 20,
  "offset": 0,
  "sort_by": "holders",
  "order": "desc",
  "searchQuery": "DIESEL"
}
Example response
{
  "statusCode": 200,
  "data": {
    "count": 1,
    "limit": 20,
    "offset": 0,
    "total": 1,
    "tokens": [
      {
        "alkaneId": {
          "block": "2",
          "tx": "0"
        },
        "name": "DIESEL",
        "symbol": "DIESEL",
        "holders": 6409,
        "fdvUsd": 47790983.31
      }
    ]
  }
}
/get-alkane-detailsPOST

Returns detailed metadata and market fields for one Alkane.

Use this when you already know the Alkane id and need the explorer's normalized metadata, display fields, and indexed creation context.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-alkane-details
{
  "alkaneId": {
    "block": "2",
    "tx": "0"
  }
}
Example response
{
  "alkane": {
    "id": "2:0"
  }
}
/get-poolsPOST

Lists pools for a factory.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-pools
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  },
  "limit": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "limit": 20,
  "offset": 0,
  "total": 149,
  "data": [
    {
      "block": "2",
      "tx": "53014"
    },
    {
      "block": "2",
      "tx": "53044"
    }
  ]
}
/get-pool-detailsPOST

Returns details for one factory pool.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-pool-details
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  },
  "poolId": {
    "block": "2",
    "tx": "53014"
  }
}
Example response
{
  "pool": {
    "id": "2:53014"
  }
}
/get-pool-swap-historyPOST

Returns swap history for a pool.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/get-pool-swap-history
{
  "poolId": {
    "block": "2",
    "tx": "53014"
  },
  "count": 20,
  "offset": 0,
  "successful": true,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": {
      "pool": {
        "poolId": {
          "block": "2",
          "tx": "53014"
        },
        "poolName": "DIESEL / CH4"
      },
      "swaps": [
        {
          "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
          "soldTokenBlockId": "2",
          "soldTokenTxId": "0",
          "boughtTokenBlockId": "2",
          "boughtTokenTxId": "16",
          "soldAmount": "11486258",
          "boughtAmount": "1061552883247",
          "timestamp": "2026-05-26T21:34:29Z"
        }
      ],
      "count": 1,
      "offset": 0,
      "total": 2868
    },
    "count": 1,
    "offset": 0,
    "total": 2868
  }
}
/get-token-swap-historyPOST

Returns swap history for a token across pools.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-token-swap-history
{
  "tokenId": {
    "block": "2",
    "tx": "0"
  },
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "soldTokenBlockId": "2",
        "soldTokenTxId": "0",
        "boughtTokenBlockId": "2",
        "boughtTokenTxId": "16",
        "soldAmount": "11486258",
        "boughtAmount": "1061552883247",
        "seller地址": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
        "timestamp": "2026-05-26T21:34:29Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 19041
  }
}
/get-pool-mint-historyPOST

Returns liquidity mint history for a pool.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-pool-mint-history
{
  "poolId": {
    "block": "2",
    "tx": "53014"
  },
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "89c7a58ba8dc9e7efda8cd8d50cf397313999f69b43149c4214ff6a15507c7c2",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0BlockId": "2",
        "token0TxId": "0",
        "token1BlockId": "2",
        "token1TxId": "16",
        "token0Amount": "244212912",
        "token1Amount": "20600",
        "lpTokenAmount": "70915448",
        "minter地址": "bc1pf8c420ues7wvh0fgmh56675xsm4as33ms006tee876h3v08y5yqqfruu2w",
        "timestamp": "2025-02-18T21:08:26Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 296
  }
}
/get-pool-burn-historyPOST

Returns liquidity burn history for a pool.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-pool-burn-history
{
  "poolId": {
    "block": "2",
    "tx": "53014"
  },
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "fd6f91549cc1ea3d5803406a9ab8679562e3d780f4bb099320b490af0680262f",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0BlockId": "2",
        "token0TxId": "0",
        "token1BlockId": "2",
        "token1TxId": "16",
        "token0Amount": "8128760",
        "token1Amount": "609138011383",
        "lpTokenAmount": "2366448",
        "burner地址": "bc1qnlaz6rt6734pfd23ehx68nyczs5pfjdp6ct0aa",
        "timestamp": "2026-05-13T14:24:53Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 159
  }
}
/get-pool-creation-historyPOST

Returns pool creation events.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-pool-creation-history
{
  "poolId": null,
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "89c7a58ba8dc9e7efda8cd8d50cf397313999f69b43149c4214ff6a15507c7c2",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0BlockId": "2",
        "token0TxId": "0",
        "token1BlockId": "2",
        "token1TxId": "16",
        "token0Amount": "244212912",
        "token1Amount": "20600",
        "creator地址": "bc1pf8c420ues7wvh0fgmh56675xsm4as33ms006tee876h3v08y5yqqfruu2w",
        "timestamp": "2025-02-18T21:08:26Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 149
  }
}
/get-address-swap-history-for-poolPOST

Returns swap history for an address in one pool.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-address-swap-history-for-pool
{
  "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
  "poolId": {
    "block": "2",
    "tx": "53014"
  },
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "soldTokenBlockId": "2",
        "soldTokenTxId": "0",
        "boughtTokenBlockId": "2",
        "boughtTokenTxId": "16",
        "soldAmount": "11486258",
        "boughtAmount": "1061552883247",
        "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
        "timestamp": "2026-05-26T21:34:29Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/get-address-swap-history-for-tokenPOST

Returns swap history for an address and one token.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-address-swap-history-for-token
{
  "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
  "tokenId": {
    "block": "2",
    "tx": "0"
  },
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "soldTokenBlockId": "2",
        "soldTokenTxId": "0",
        "boughtTokenBlockId": "2",
        "boughtTokenTxId": "16",
        "soldAmount": "11486258",
        "boughtAmount": "1061552883247",
        "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
        "timestamp": "2026-05-26T21:34:29Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/get-address-wrap-historyPOST

Returns frBTC wrap events for an address.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/get-address-wrap-history
{
  "address": "bc1p9qftzwgufdv5h7zk674jvppfjfa9eys56zzflfvvrg4cekpwfy9s3yerpx",
  "count": 20,
  "offset": 0,
  "successful": true,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "7edddf6ee5f6e39e503a8c9c7f80ff27285e2da37b61d6728b40f5903f316f36",
        "address": "bc1p9qftzwgufdv5h7zk674jvppfjfa9eys56zzflfvvrg4cekpwfy9s3yerpx",
        "amount": "100000",
        "timestamp": "2026-05-20T16:28:50Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 3565
  }
}
/get-address-unwrap-historyPOST

Returns frBTC unwrap events for an address.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/get-address-unwrap-history
{
  "address": "bc1q2l9yryzdq82pteuhrjt93cuvgazr5ph8z5zgqw",
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "address": "bc1q2l9yryzdq82pteuhrjt93cuvgazr5ph8z5zgqw",
        "amount": "100000",
        "timestamp": "2026-05-20T09:51:42Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 2339
  }
}
/get-all-wrap-historyPOST

Returns global frBTC wrap events.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/get-all-wrap-history
{
  "count": 20,
  "offset": 0,
  "successful": true,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "7edddf6ee5f6e39e503a8c9c7f80ff27285e2da37b61d6728b40f5903f316f36",
        "address": "bc1p9qftzwgufdv5h7zk674jvppfjfa9eys56zzflfvvrg4cekpwfy9s3yerpx",
        "amount": "100000",
        "timestamp": "2026-05-20T16:28:50Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 3565
  }
}
/get-all-unwrap-historyPOST

Returns global frBTC unwrap events.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/get-all-unwrap-history
{
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "b1267c0dcf9de9fb8a8b5bb4d34da75ae7dca36abf3361906c7f83c6e661f155",
        "address": "bc1q2l9yryzdq82pteuhrjt93cuvgazr5ph8z5zgqw",
        "amount": "100000",
        "timestamp": "2026-05-20T09:51:42Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 2339
  }
}
/get-total-unwrap-amountPOST

Returns the total unwrapped amount at latest or at a block height.

Subfrost history endpoints are event indexes for frBTC flows. Use success and fulfillment filters to separate requested actions from completed ones.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
  • `successful` filters contract events by trace success state. Omit it to include both successes and failures.
Example query
POST https://api.alkanode.com/get-total-unwrap-amount
{
  "blockHeight": 946000,
  "successful": true
}
Example response
{
  "amount": "100000000"
}
/get-address-pool-creation-historyPOST

Returns pool creation history associated with an address.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-address-pool-creation-history
{
  "address": "bc1pqd8pq7pchx2wheh5gx0rgg6rkt7en3pvlrhphaq4gntvnt3mm7dqxwzm2e",
  "poolId": {
    "block": "2",
    "tx": "53014"
  },
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "89c7a58ba8dc9e7efda8cd8d50cf397313999f69b43149c4214ff6a15507c7c2",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0BlockId": "2",
        "token0TxId": "0",
        "token1BlockId": "2",
        "token1TxId": "16",
        "creator地址": "bc1pqd8pq7pchx2wheh5gx0rgg6rkt7en3pvlrhphaq4gntvnt3mm7dqxwzm2e",
        "timestamp": "2025-02-18T21:08:26Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/get-address-pool-mint-historyPOST

Returns liquidity mint history associated with an address.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/get-address-pool-mint-history
{
  "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "89c7a58ba8dc9e7efda8cd8d50cf397313999f69b43149c4214ff6a15507c7c2",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0Amount": "244212912",
        "token1Amount": "20600",
        "lpTokenAmount": "70915448",
        "minter地址": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
        "timestamp": "2025-02-18T21:08:26Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/get-address-pool-burn-historyPOST

Returns liquidity burn history associated with an address.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/get-address-pool-burn-history
{
  "address": "bc1pmwsf07u2s53gfq38jlafq4w0dgw3x5kquh2ayx465nnsghphjrjqs5k0l7",
  "count": 20,
  "offset": 0
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "fd6f91549cc1ea3d5803406a9ab8679562e3d780f4bb099320b490af0680262f",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "token0Amount": "8128760",
        "token1Amount": "609138011383",
        "lpTokenAmount": "2366448",
        "burner地址": "bc1pmwsf07u2s53gfq38jlafq4w0dgw3x5kquh2ayx465nnsghphjrjqs5k0l7",
        "timestamp": "2026-05-13T14:24:53Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/address-positionsPOST

Returns an address position summary for pools under a factory.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/address-positions
{
  "address": "bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8",
  "factoryId": {
    "block": "4",
    "tx": "65522"
  }
}
Example response
{
  "statusCode": 200,
  "data": {
    "positions": [
      {
        "poolId": {
          "block": "2",
          "tx": "53014"
        },
        "poolName": "DIESEL / CH4",
        "lp余额": "2366448",
        "token0Amount": "8128760",
        "token1Amount": "609138011383",
        "valueInUsd": 96.22
      }
    ]
  }
}
/get-all-pools-detailsPOST

Returns detailed pool rows for a factory with search, sort, paging, and optional address filtering.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • 搜索 text is matched against indexed token or pool metadata and may be capped by module search limits.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
Example query
POST https://api.alkanode.com/get-all-pools-details
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  },
  "limit": 20,
  "offset": 0,
  "sort_by": "volume",
  "order": "desc",
  "searchQuery": "",
  "address": null
}
Example response
{
  "statusCode": 200,
  "data": {
    "count": 1,
    "limit": 20,
    "offset": 0,
    "total": 149,
    "totalPoolVolume24h": 676270.3489941867,
    "largestPool": {
      "poolId": {
        "block": "2",
        "tx": "53014"
      },
      "poolName": "DIESEL / CH4",
      "poolApr": 14.7428,
      "creationBlockHeight": 916291
    },
    "pools": [
      {
        "poolId": {
          "block": "2",
          "tx": "53014"
        },
        "poolName": "DIESEL / CH4",
        "reserve0": "21486066722",
        "reserve1": "1624687948631013",
        "poolTvlInUsd": 35819.907581967265,
        "poolVolume1dInUsd": 15526.198504698415
      }
    ]
  }
}
/get-all-address-amm-tx-historyPOST

Returns all AMM transaction history for an address.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/get-all-address-amm-tx-history
{
  "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
  "transactionType": "swap",
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "type": "swap",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "soldAmount": "11486258",
        "boughtAmount": "1061552883247",
        "address": "bc1p4g0w7n3yjuzpx5s6umw03mzca49ktkmvxm976nyv0k272m2vl48slrrw5l",
        "timestamp": "2026-05-26T21:34:29Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 1
  }
}
/get-all-amm-tx-historyPOST

Returns global AMM transaction history.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/get-all-amm-tx-history
{
  "transactionType": "swap",
  "count": 20,
  "offset": 0,
  "includeTotal": true
}
Example response
{
  "statusCode": 200,
  "data": {
    "items": [
      {
        "transactionId": "02146673f5ba09a67042626a21727466a3ac4c68bdce49e12fd9f734133489d3",
        "type": "swap",
        "poolBlockId": "2",
        "poolTxId": "53014",
        "soldTokenBlockId": "2",
        "soldTokenTxId": "0",
        "boughtTokenBlockId": "2",
        "boughtTokenTxId": "16",
        "soldAmount": "11486258",
        "boughtAmount": "1061552883247",
        "timestamp": "2026-05-26T21:34:29Z"
      }
    ],
    "count": 1,
    "offset": 0,
    "total": 25372
  }
}
/get-all-token-pairsPOST

Returns all token pairs known for a factory.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-all-token-pairs
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  }
}
Example response
{
  "statusCode": 200,
  "data": [
    {
      "poolId": {
        "block": "2",
        "tx": "53014"
      },
      "poolName": "DIESEL / CH4",
      "reserve0": "21486066722",
      "reserve1": "1624687948631013",
      "poolTvlInUsd": 35819.907581967265,
      "poolVolume1dInUsd": 15526.198504698415,
      "token0": {
        "alkaneId": {
          "block": "2",
          "tx": "0"
        },
        "name": "DIESEL",
        "symbol": "DIESEL",
        "token0Amount": "21486066722"
      },
      "token1": {
        "alkaneId": {
          "block": "2",
          "tx": "16"
        },
        "name": "CH4",
        "symbol": "CH4",
        "token1Amount": "1624687948631013"
      }
    }
  ]
}
/get-token-pairsPOST

Returns pairs for one token under a factory.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
  • 搜索 text is matched against indexed token or pool metadata and may be capped by module search limits.
  • Sort fields are route-specific. Unsupported values fall back to the handler default or return a validation error, depending on the route.
Example query
POST https://api.alkanode.com/get-token-pairs
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  },
  "alkaneId": {
    "block": "2",
    "tx": "0"
  },
  "sort_by": "volume",
  "limit": 20,
  "offset": 0,
  "searchQuery": ""
}
Example response
{
  "statusCode": 200,
  "data": [
    {
      "poolId": {
        "block": "2",
        "tx": "53014"
      },
      "poolName": "DIESEL / CH4",
      "reserve0": "21486066722",
      "reserve1": "1624687948631013",
      "poolTvlInUsd": 35819.907581967265,
      "poolVolume1dInUsd": 15526.198504698415,
      "token0": {
        "alkaneId": {
          "block": "2",
          "tx": "0"
        },
        "name": "DIESEL",
        "symbol": "DIESEL"
      },
      "token1": {
        "alkaneId": {
          "block": "2",
          "tx": "16"
        },
        "name": "CH4",
        "symbol": "CH4"
      }
    }
  ]
}
/get-alkane-swap-pair-detailsPOST

Returns details for a token pair under a factory.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/get-alkane-swap-pair-details
{
  "factoryId": {
    "block": "4",
    "tx": "65522"
  },
  "tokenAId": {
    "block": "2",
    "tx": "0"
  },
  "tokenBId": {
    "block": "2",
    "tx": "16"
  }
}
Example response
{
  "statusCode": 200,
  "data": [
    {
      "path": [
        {
          "block": "2",
          "tx": "0"
        },
        {
          "block": "2",
          "tx": "16"
        }
      ],
      "pools": [
        {
          "poolId": {
            "block": "2",
            "tx": "53014"
          },
          "poolName": "DIESEL / CH4",
          "reserve0": "21486066722",
          "reserve1": "1624687948631013"
        }
      ]
    }
  ]
}

Explorer HTTP API

HTTP and websocket endpoints used by the explorer interface.

/api/block/pool?height=946000GET

Returns mining pool attribution for a block.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
GET https://api.alkanode.com/api/block/pool?height=946000
Example response
{
  "height": 946000,
  "pool": "未知"
}
/api/mempool/blocksGET

Returns projected mempool block summaries for the explorer.

AMM endpoints use pool and factory ids from indexed contracts. Route calculations are informational and clients should still validate transactions before broadcast.

Example query
GET https://api.alkanode.com/api/mempool/blocks
Example response
{
  "tx_count": 97385,
  "updated_at": 1779900427,
  "sequence": 1449,
  "status": {
    "phase": "in_sync",
    "in_sync": true,
    "hydrating": false,
    "stale": false
  },
  "blocks": [
    {
      "index": 0,
      "tx_count": 3879,
      "trace_count": 2119,
      "weight": 3987528,
      "vsize": 998957,
      "total_fees": 2224788,
      "median_fee_rate": 1.3,
      "min_fee_rate": 1.001531393568147
    }
  ],
  "deltas": [
    {
      "index": 0,
      "tx_count": 3879,
      "trace_count": 2119
    }
  ]
}
/api/faucet/statusGET

Returns B8's separate rBTC and DIESEL faucet settings, spendable balances, minimum and maximum request amounts, rolling 24-hour usage, and configured caps when the regtest faucet is enabled. The top-level fields mirror rBTC for compatibility.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

Example query
GET https://api.alkanode.com/api/faucet/status
Example response
{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "amount": 1.0,
    "enabled": true,
    "max_amount": 1.0,
    "rbtc": {
      "amount": 1.0,
      "claims_last_24h": 2,
      "enabled": true,
      "min_amount": 0.1,
      "max_amount": 1.0,
      "total_available": 149.5,
      "max_per_address_per_day": 10.0,
      "max_per_day": 500.0,
      "max_per_ip_per_day": 10.0,
      "sent_last_24h": 2.0
    },
    "diesel": {
      "amount": 10.0,
      "claims_last_24h": 3,
      "enabled": true,
      "min_amount": 1.0,
      "max_amount": 10.0,
      "total_available": 3200.0,
      "max_per_address_per_day": 100.0,
      "max_per_day": 5000.0,
      "max_per_ip_per_day": 100.0,
      "sent_last_24h": 8.0
    }
  }
}
/api/faucet/sendPOST

Requests rBTC or DIESEL within that asset's configured B8 faucet minimum and maximum for one regtest address. asset defaults to rbtc when omitted. Omitting amount retains B8's maximum-payout behavior. Available only on regtest when b8_faucet_url is configured.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
Example query
POST https://api.alkanode.com/api/faucet/send
{
  "address": "bcrt1q...",
  "amount": 3.0,
  "asset": "diesel"
}
Example response
{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "amount": 3.0,
    "asset": "diesel",
    "txid": "7be14a09c9..."
  }
}
/api/search/guess?q=2%3A0GET

Returns search suggestions and target type guesses.

HTTP methods are compatibility routes used by the explorer and Oyl-style clients; they wrap indexed data into route-specific response shapes.

Example query
GET https://api.alkanode.com/api/search/guess?q=2%3A0
Example response
{
  "query": "2:0",
  "groups": [
    {
      "kind": "alkanes",
      "title": "Alkanes",
      "items": [
        {
          "label": "DIESEL",
          "href": "/alkane/2:0",
          "subtitle": "2:0"
        }
      ]
    }
  ]
}
/api/alkane/simulatePOST

Simulates an Alkane 合约调用 from the explorer.

Simulation executes against indexed state and is meant for previewing contract behavior before building or broadcasting a transaction.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/api/alkane/simulate
{
  "alkane": "2:0",
  "opcode": 99,
  "inputs": []
}
Example response
{
  "ok": true,
  "result": null
}
/api/alkane/holders/export?alkane=2%3A0GET

Exports holders for an Alkane as a downloadable response.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/alkane/holders/export?alkane=2%3A0
Example response
{
  "content_type": "text/csv"
}
/api/alkane/wasm/export?alkane=2%3A0GET

Downloads the resolved contract WASM. Proxy implementations and 工厂克隆s use the same indexed source resolution as Alkabi exports.

Export routes are built for downloads and can return file content instead of a typical JSON document depending on the requested format.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/alkane/wasm/export?alkane=2%3A0
Example response
{
  "content_type": "application/wasm",
  "filename": "alkane-2-0.wasm"
}
/api/alkane/chart?alkane=2%3A16&source=derived&quote=2%3A0GET

Returns chart series data for an Alkane metric.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/alkane/chart?alkane=2%3A16&source=derived&quote=2%3A0
Example response
{
  "ok": true,
  "available": true,
  "range": "3m",
  "source": "derived",
  "quote": "2:0",
  "candles": [
    {
      "ts": 1779890400,
      "close": 0.00001234
    }
  ],
  "error": null
}
/api/alkane/balance-chart?alkane=2%3A53014&balance_alkane=2%3A0GET

Returns balance chart data for an address and Alkane.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/alkane/balance-chart?alkane=2%3A53014&balance_alkane=2%3A0
Example response
{
  "ok": true,
  "available": true,
  "range": "1d",
  "points": [
    {
      "height": 951000,
      "value": 214.86066722
    }
  ],
  "error": null
}
/api/minting-price-chart?alkane=2%3A0GET

Returns minting price chart data for an Alkane.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/minting-price-chart?alkane=2%3A0
Example response
{
  "ok": true,
  "available": true,
  "range": "all",
  "points": [
    {
      "height": 880500,
      "value": 0.495472
    },
    {
      "height": 881000,
      "value": 0.0990944
    }
  ],
  "error": null
}
/api/address/chart?address=bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8&alkane=2%3A0GET

Returns address-level chart data for explorer pages.

市场 and chart data is derived from indexed AMM activity. Missing buckets or sparse periods can occur when no qualifying events were indexed.

What to know
  • Bitcoin addresses are validated for the configured network, so mainnet, testnet, signet, and regtest addresses are not interchangeable.
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
GET https://api.alkanode.com/api/address/chart?address=bc1phqvgwn7wn5e4s8g0999rtgafd07jpuuy59rkdrk4s5thw9jafkasg8umr8&alkane=2%3A0
Example response
{
  "ok": true,
  "available": true,
  "range": "all",
  "points": [
    {
      "height": 946000,
      "value": 309500.01348973
    }
  ],
  "error": null
}
/api/rune/holders/export?rune=1%3A0GET

Exports holders for a Rune when the runes module is enabled.

余额s are derived from indexed UTXO state, so historical reads reflect the indexer's view at that height rather than a wallet's local cache.

Example query
GET https://api.alkanode.com/api/rune/holders/export?rune=1%3A0
Example response
{
  "content_type": "text/csv"
}
/api/events/wsWEBSOCKET

Streams explorer events when websocket support is enabled. Clients receive only the categories and identifiers requested with `action: want`: `block`, `mempool-blocks`, a specific `txid`, or a specific `address`. Transaction and address batches are narrowed server-side to the tracked values. A transaction request returns its current status immediately and then streams only that transaction's mempool and 次确认 changes on the same connection.

The websocket sends event messages as the explorer observes chain and mempool changes, so consumers should handle reconnects and duplicate state updates.

Example query
WEBSOCKET https://api.alkanode.com/api/events/ws
{
  "action": "want",
  "data": [
    "tx"
  ],
  "txid": "4d3f...9a10"
}
Example response
{
  "type": "tx-status",
  "data": {
    "txid": "4d3f...9a10",
    "status": "confirmed",
    "height": 958411,
    "timestamp": 1784382000,
    "confirmations": 2
  }
}

Internal getter RPC

Getter-level RPC methods that let a remote espo explorer (configured with explorer_espo_rpc_host, which is used verbatim as the endpoint URL and so must include the /rpc path) render entirely from RPC calls against this instance: every storage getter the explorer uses is mirrored as internal.<module>_<getter>, so one getter invocation is exactly one round-trip carrying the getter's full native result. Requests carry the getter's native params struct as "p" (serde JSON; blockhash pins versioned state) and responses return the native result as "r" — simple results as plain JSON, heavy nested results (creation records, block summaries, tx summaries, pointer blobs, holder pages, rune entries) as hex-encoded Borsh in *_borsh fields, the same encoding they are stored with. Registered only when enable_internal_rpc is true, which requires internal_rpc_key: every request must carry the key as "auth" or it is rejected with unauthorized (the remote explorer sends it automatically from explorer_espo_rpc_key). These methods exist for trusted explorer replicas — keep them off untrusted public endpoints. The full method list mirrors the getter names in each module's internal_rpc.rs (essentials, runes, ammdata, tokendata, pizzafun, subfrost) plus internal.tree_blockhash_for_height and internal.tree_indexed_height_bounds.

internal.essentials_get_holders_countJSON-RPC

Representative example of a simple getter: native params in, native result out as plain JSON.

This returns the aggregate count only; use the holder list endpoints when you need balances, address rows, or pagination.

What to know
  • Alkane ids use the `<block>:<tx>` identity. Oyl-compatible HTTP bodies split the same id into `{ "block": "...", "tx": "..." }`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "internal.essentials_get_holders_count",
  "params": {
    "auth": "<internal_rpc_key>",
    "p": {
      "blockhash": "Latest",
      "alkane": {
        "block": 2,
        "tx": 0
      }
    }
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "r": {
      "count": 6409
    }
  },
  "id": 1
}
internal.essentials_get_creation_records_ordered_pageJSON-RPC

Representative example of a heavy getter: the result rows are hex-encoded Borsh in the stored encoding.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • `page` pagination is 1-based. `limit` may be clamped by the handler to protect the backing index.
  • `count` and `offset` use offset-based pagination. Request totals only when the endpoint supports `includeTotal` or `include_total`.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "internal.essentials_get_creation_records_ordered_page",
  "params": {
    "auth": "<internal_rpc_key>",
    "p": {
      "blockhash": "Latest",
      "offset": 0,
      "limit": 2,
      "desc": true
    }
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "r": {
      "records": [
        "01a3f2…",
        "01b871…"
      ]
    }
  },
  "id": 1
}
internal.tree_blockhash_for_heightJSON-RPC

Resolves an indexed height to its canonical blockhash (internal byte order, hex); remote explorers use it for height-pinned views.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

What to know
  • Height filters resolve against indexed chain state. Omitting an optional height generally means the latest indexed height.
Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "internal.tree_blockhash_for_height",
  "params": {
    "auth": "<internal_rpc_key>",
    "p": {
      "height": 946000
    }
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "r": {
      "blockhash": "0000000000000000000000000000000000000000000000000000000000000000"
    }
  },
  "id": 1
}
internal.tree_indexed_height_boundsJSON-RPC

Returns the (min, max) indexed heights of the versioned tree, or null when nothing is indexed.

This RPC reads Espo's indexed state and returns a normalized JSON shape intended for explorers, wallets, analytics jobs, or integration tests.

Example query
POST https://api.alkanode.com/rpc
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "internal.tree_indexed_height_bounds",
  "params": {
    "auth": "<internal_rpc_key>",
    "p": {}
  }
}
Example response
{
  "jsonrpc": "2.0",
  "result": {
    "ok": true,
    "r": {
      "bounds": [
        880000,
        946000
      ]
    }
  },
  "id": 1
}