MCP catalogue

BlockQuery MCP tools

Live tool surface for Bitcoin chain lookups, risk scoring, credits, and Lightning payment flow. Prefer batch tools ending in _multi when screening many ids.

Tools

Endpoint

https://blockquery-resources-dev.chainprint.tech/mcp

Auth

Bearer token

Chainspector (21)

address_exists_multi

Batch chainspect `address_exists_multi`: look up many Bitcoin addresses in one call. Pass as many Bitcoin addresses as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `addresses` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: addresses: List of Bitcoin addresses, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`addresses`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<boolean> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "boolean"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "address_exists_multiOutput",
  "type": "object"
}

address_output_count_multi

Batch chainspect `address_output_count_multi`: look up many Bitcoin addresses in one call. Pass as many Bitcoin addresses as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `addresses` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: addresses: List of Bitcoin addresses, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`addresses`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "address_output_count_multiOutput",
  "type": "object"
}

address_outputs_multi

Batch chainspect `address_outputs_multi`: look up many Bitcoin addresses in one call. Pass as many Bitcoin addresses as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `addresses` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: addresses: List of Bitcoin addresses, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`addresses`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<string>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "address_outputs_multiOutput",
  "type": "object"
}

block_height_txs_multi

Batch chainspect `block_height_txs_multi`: look up many block heights in one call. Pass as many block heights as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `block_heights` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: block_heights: List of block heights, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`block_heights`	`array<integer> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<string>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "block_height_txs_multiOutput",
  "type": "object"
}

get_resource

Fetch the values stored in a resource by its UUID. Use this to read back a result an earlier call stashed with `store_result=True` — e.g. to inspect the final answer of a chain. When you are only chaining, prefer passing the resource id straight into the next batch tool; call this only when you actually need the values in context. Args: resource_id: UUID returned by a previous call's resource handle. Returns: The stored value and its item count. Raises if the resource is unknown or has expired (resources live for one hour).

argument	type	required	description
`resource_id`	`string`	yes

Returns: get_resourceDictOutput

output schema

{
  "additionalProperties": true,
  "title": "get_resourceDictOutput",
  "type": "object"
}

latest_block

Return the height of the latest Bitcoin block processed by chainspect. Returns: The block height (e.g. 801387) of the most recently processed block.

No arguments.

Returns: integer

output schema

{
  "properties": {
    "result": {
      "title": "Result",
      "type": "integer"
    }
  },
  "required": [
    "result"
  ],
  "title": "latest_blockOutput",
  "type": "object"
}

output_address_multi

Batch chainspect `output_address_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<string | null> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_address_multiOutput",
  "type": "object"
}

output_exists_multi

Batch chainspect `output_exists_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<boolean> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "boolean"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_exists_multiOutput",
  "type": "object"
}

output_next_tx_multi

Batch chainspect `output_next_tx_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<string>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_next_tx_multiOutput",
  "type": "object"
}

output_script_type_multi

Batch chainspect `output_script_type_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<string> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_script_type_multiOutput",
  "type": "object"
}

output_tx_multi

Batch chainspect `output_tx_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<string> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_tx_multiOutput",
  "type": "object"
}

output_value_multi

Batch chainspect `output_value_multi`: look up many output ids (<txid>_<n>) in one call. Pass as many output ids (<txid>_<n>) as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `outputs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: outputs: List of output ids (<txid>_<n>), or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`outputs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "output_value_multiOutput",
  "type": "object"
}

tx_block_height_multi

Batch chainspect `tx_block_height_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_block_height_multiOutput",
  "type": "object"
}

tx_exists_multi

Batch chainspect `tx_exists_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<boolean> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "boolean"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_exists_multiOutput",
  "type": "object"
}

tx_input_count_multi

Batch chainspect `tx_input_count_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_input_count_multiOutput",
  "type": "object"
}

tx_inputs_multi

Batch chainspect `tx_inputs_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<string>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_inputs_multiOutput",
  "type": "object"
}

tx_locktime_multi

Batch chainspect `tx_locktime_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_locktime_multiOutput",
  "type": "object"
}

tx_mined_timestamp_multi

Batch chainspect `tx_mined_timestamp_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_mined_timestamp_multiOutput",
  "type": "object"
}

tx_output_count_multi

Batch chainspect `tx_output_count_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_output_count_multiOutput",
  "type": "object"
}

tx_outputs_multi

Batch chainspect `tx_outputs_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<string>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_outputs_multiOutput",
  "type": "object"
}

tx_vsize_multi

Batch chainspect `tx_vsize_multi`: look up many transaction ids in one call. Pass as many transaction ids as you can in one call — prefer a single large batch over many small calls; do not loop this per item. To chain calls without moving large data through the conversation, pass a resource id (a UUID returned by an earlier call's `store_result`) as `txs` instead of a literal list; a nested stored result is flattened automatically. Set `store_result=True` to store this call's output server-side and get back a resource handle (its id plus TTL) instead of the full array. Args: txs: List of transaction ids, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One result per input, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`txs`	`array<string> \| string`	yes
`store_result`	`boolean`	no

Returns: array<integer> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "tx_vsize_multiOutput",
  "type": "object"
}

Labelshub (1)

btc_usd_multi

Batch BTC/USD lookup: price labels per block height. Reads the `blockheight_btcusd_clovrlabs` labelshub dataset. Consumes 1 credit from the authenticated bearer token. Args: block_heights: List of Bitcoin block heights, or a resource id (UUID string) to load them from. store_result: If true, store the result as a resource and return a handle instead of the inline array. Returns: One list of label payloads per input block height, in the same order — or a ResourceHandle when store_result is true.

argument	type	required	description
`block_heights`	`array<integer> \| string`	yes
`store_result`	`boolean`	no

Returns: array<array<object>> | ResourceHandle

output schema

{
  "$defs": {
    "ResourceHandle": {
      "description": "A reference to a large result stored server-side instead of returned inline.\n\nReturned by a tool when `store_result=True`. Pass `resource_id` back as the\nlist argument of another batch tool to chain calls without re-sending the\ndata, or fetch the values with the `get_resource` tool. The resource is\ndeleted automatically once it expires.",
      "properties": {
        "resource_id": {
          "description": "UUID identifying the stored result. Use it as the list argument of a compatible *_multi tool, or pass it to get_resource.",
          "title": "Resource Id",
          "type": "string"
        },
        "item_count": {
          "description": "Number of items stored in the resource.",
          "title": "Item Count",
          "type": "integer"
        },
        "ttl_seconds": {
          "description": "Seconds until the resource expires and is deleted.",
          "title": "Ttl Seconds",
          "type": "integer"
        },
        "expires_at": {
          "description": "Unix epoch seconds at which the resource expires.",
          "title": "Expires At",
          "type": "integer"
        },
        "stored": {
          "default": true,
          "description": "Always true: the result was stored as a resource rather than returned inline.",
          "title": "Stored",
          "type": "boolean"
        }
      },
      "required": [
        "resource_id",
        "item_count",
        "ttl_seconds",
        "expires_at"
      ],
      "title": "ResourceHandle",
      "type": "object"
    }
  },
  "properties": {
    "result": {
      "anyOf": [
        {
          "items": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/ResourceHandle"
        }
      ],
      "title": "Result"
    }
  },
  "required": [
    "result"
  ],
  "title": "btc_usd_multiOutput",
  "type": "object"
}

Pingu gRPC algorithms (2)

address_funds

Trace clustered funds for an address (pingu gRPC `AddressFunds`). Consumes 1 credit from the authenticated bearer token. Args: address: Bitcoin address. threshold: Minimum fund fraction to include (0-1). direction: "SOF" (source of funds) or "DOF" (destination of funds). max_block_height: Optional cap on the block height considered. Returns: Traced funds grouped by entity (amounts, share, and hop range).

argument	type	required
`address`	`string`	yes
`threshold`	`number`	yes
`direction`	`string`	no
`max_block_height`	`integer \| null`	no

Returns: ClusterFunds

output schema

{
  "$defs": {
    "Amount": {
      "description": "A fund amount. Values are 4-decimal-rounded so fractional shares survive.",
      "properties": {
        "satoshis": {
          "default": 0.0,
          "description": "Amount in satoshis (fractional).",
          "title": "Satoshis",
          "type": "number"
        },
        "usd_cents": {
          "default": 0.0,
          "description": "Amount in USD cents.",
          "title": "Usd Cents",
          "type": "number"
        }
      },
      "title": "Amount",
      "type": "object"
    },
    "EntityFunds": {
      "description": "Funds attributed to a single entity.",
      "properties": {
        "name": {
          "default": "",
          "description": "Entity name.",
          "title": "Name",
          "type": "string"
        },
        "category": {
          "default": "",
          "description": "Entity category.",
          "title": "Category",
          "type": "string"
        },
        "amount": {
          "$ref": "#/$defs/Amount",
          "description": "Funds attributed to the entity."
        },
        "percentage": {
          "default": 0.0,
          "description": "Share of the total traced funds (0-1).",
          "title": "Percentage",
          "type": "number"
        },
        "hops": {
          "$ref": "#/$defs/HopRange",
          "description": "Hop-count range to the entity."
        }
      },
      "title": "EntityFunds",
      "type": "object"
    },
    "HopRange": {
      "description": "Inclusive range of hop counts between the address and the entity.",
      "properties": {
        "min": {
          "default": 0,
          "description": "Fewest hops.",
          "title": "Min",
          "type": "integer"
        },
        "max": {
          "default": 0,
          "description": "Most hops.",
          "title": "Max",
          "type": "integer"
        }
      },
      "title": "HopRange",
      "type": "object"
    }
  },
  "description": "Funds traced to/from an address, grouped by entity id.",
  "properties": {
    "entities": {
      "additionalProperties": {
        "$ref": "#/$defs/EntityFunds"
      },
      "description": "Entity id -> attributed funds.",
      "title": "Entities",
      "type": "object"
    }
  },
  "title": "ClusterFunds",
  "type": "object"
}

address_volume

Total in/out volume for an address (pingu gRPC `AddressVolume`). Args: address: Bitcoin address. Returns: Received (source) and sent (destination) volume in satoshis and USD.

argument	type	required	description
`address`	`string`	yes

Returns: AddressVolume

output schema

{
  "$defs": {
    "VolumeAmount": {
      "description": "A volume figure in both satoshis and USD.",
      "properties": {
        "satoshis": {
          "default": 0,
          "description": "Amount in satoshis.",
          "title": "Satoshis",
          "type": "integer"
        },
        "usd": {
          "default": 0.0,
          "description": "Amount in USD.",
          "title": "Usd",
          "type": "number"
        }
      },
      "title": "VolumeAmount",
      "type": "object"
    }
  },
  "description": "Total volume flowing into (source) and out of (destination) an address.",
  "properties": {
    "source": {
      "$ref": "#/$defs/VolumeAmount",
      "description": "Received (source) volume."
    },
    "destination": {
      "$ref": "#/$defs/VolumeAmount",
      "description": "Sent (destination) volume."
    },
    "max_block_height": {
      "default": 0,
      "description": "Highest block height considered for the result.",
      "title": "Max Block Height",
      "type": "integer"
    }
  },
  "title": "AddressVolume",
  "type": "object"
}

ScoreMyCrypto risk scoring (2)

score_address

Risk-score a Bitcoin address with ScoreMyCrypto. Runs a full address risk assessment: an overall `risk_score`, a source- and destination-of-funds breakdown by entity category, counterparty identification, and a blacklist flag. Args: address: Bitcoin address to analyze. ai_confidence_threshold: Enable AI-inferred labels at this minimum confidence ("low", "medium", "high"). Omit to disable AI analysis. Returns: A terminal risk job. When `state` is "COMPLETED" the `result` field holds the address risk result. `state` "FAILED" is terminal (see `error_message`); "ValueError: address not found" means the address has no on-chain history. If the job is still pending after SCOREMYCRYPTO_MAX_WAIT, the tool times out and the reserved credit is refunded.

argument	type	required	description
`address`	`string`	yes
`ai_confidence_threshold`	`string \| null`	no

Returns: AddressRiskJob

output schema

{
  "$defs": {
    "AIConfidence": {
      "description": "Categorical confidence level of an AI/ML prediction.",
      "enum": [
        "LOW",
        "MED",
        "HIGH"
      ],
      "title": "AIConfidence",
      "type": "string"
    },
    "AddressBalance": {
      "description": "Current address balance.",
      "properties": {
        "balance_sats": {
          "default": 0,
          "description": "Balance in satoshis.",
          "title": "Balance Sats",
          "type": "integer"
        },
        "balance_usd": {
          "default": 0.0,
          "description": "Balance in USD.",
          "title": "Balance Usd",
          "type": "number"
        }
      },
      "title": "AddressBalance",
      "type": "object"
    },
    "AddressRiskResult": {
      "description": "Risk assessment of a Bitcoin address.",
      "properties": {
        "risk_score": {
          "default": 0.0,
          "description": "Overall risk score.",
          "title": "Risk Score",
          "type": "number"
        },
        "address": {
          "default": "",
          "description": "Analyzed Bitcoin address.",
          "title": "Address",
          "type": "string"
        },
        "include_ai_inferred_labels": {
          "default": false,
          "title": "Include Ai Inferred Labels",
          "type": "boolean"
        },
        "ai_confidence_threshold": {
          "anyOf": [
            {
              "$ref": "#/$defs/AIConfidence"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "source": {
          "additionalProperties": {
            "$ref": "#/$defs/FundAllocation"
          },
          "description": "Source-of-funds breakdown by category.",
          "title": "Source",
          "type": "object"
        },
        "ai_inferred_source": {
          "additionalProperties": {
            "$ref": "#/$defs/FundAllocation"
          },
          "title": "Ai Inferred Source",
          "type": "object"
        },
        "destination": {
          "additionalProperties": {
            "$ref": "#/$defs/FundAllocation"
          },
          "description": "Destination-of-funds breakdown by category.",
          "title": "Destination",
          "type": "object"
        },
        "ai_inferred_destination": {
          "additionalProperties": {
            "$ref": "#/$defs/FundAllocation"
          },
          "title": "Ai Inferred Destination",
          "type": "object"
        },
        "counterparty": {
          "anyOf": [
            {
              "$ref": "#/$defs/Counterparty"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Identified counterparty, if any."
        },
        "ai_inferred_counterparty": {
          "anyOf": [
            {
              "$ref": "#/$defs/Counterparty"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "risk_profile": {
          "additionalProperties": {
            "$ref": "#/$defs/RiskInfluence"
          },
          "description": "Active risk profile, by category.",
          "title": "Risk Profile",
          "type": "object"
        },
        "risky_volume": {
          "anyOf": [
            {
              "$ref": "#/$defs/RiskVolume"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "address_volume": {
          "anyOf": [
            {
              "$ref": "#/$defs/RiskVolume"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "address_balance": {
          "anyOf": [
            {
              "$ref": "#/$defs/AddressBalance"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "run_at_block_height": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "title": "Run At Block Height"
        },
        "has_blacklist_flag": {
          "default": false,
          "title": "Has Blacklist Flag",
          "type": "boolean"
        },
        "api_version": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "title": "Api Version"
        }
      },
      "title": "AddressRiskResult",
      "type": "object"
    },
    "Counterparty": {
      "description": "An entity on the other side of an address's fund flows.\n\nLabeled entities carry `name`/`category`; AI-inferred counterparties also\ncarry `probability`/`confidence`.",
      "properties": {
        "address": {
          "default": "",
          "description": "Bitcoin address of the counterparty.",
          "title": "Address",
          "type": "string"
        },
        "source": {
          "anyOf": [
            {
              "additionalProperties": {
                "$ref": "#/$defs/FundAllocation"
              },
              "type": "object"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Where this counterparty received funds from, by category.",
          "title": "Source"
        },
        "destination": {
          "anyOf": [
            {
              "additionalProperties": {
                "$ref": "#/$defs/FundAllocation"
              },
              "type": "object"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Where this counterparty sent funds to, by category.",
          "title": "Destination"
        },
        "received_amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Total USD received externally by the cluster/address.",
          "title": "Received Amount Usd"
        },
        "sent_amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Total USD sent externally by the cluster/address.",
          "title": "Sent Amount Usd"
        },
        "name": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Identified entity name, if labeled.",
          "title": "Name"
        },
        "category": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Entity category, if labeled.",
          "title": "Category"
        },
        "probability": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "ML probability (0-1), AI-inferred counterparties only.",
          "title": "Probability"
        },
        "confidence": {
          "anyOf": [
            {
              "$ref": "#/$defs/AIConfidence"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Confidence level, AI-inferred counterparties only."
        }
      },
      "title": "Counterparty",
      "type": "object"
    },
    "FundAllocation": {
      "description": "A fund-flow allocation for one entity category.\n\n`percentage` is always present. The amount/distance fields are present for\ndetailed allocations and omitted for percentage-only ones.",
      "properties": {
        "percentage": {
          "default": 0.0,
          "description": "Share of the flow (0-1).",
          "title": "Percentage",
          "type": "number"
        },
        "min_distance": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Fewest hops between the address and this category.",
          "title": "Min Distance"
        },
        "amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Allocation amount in USD.",
          "title": "Amount Usd"
        },
        "amount_sats": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Allocation amount in satoshis.",
          "title": "Amount Sats"
        }
      },
      "title": "FundAllocation",
      "type": "object"
    },
    "RiskInfluence": {
      "description": "How one risk category contributes to the overall score.",
      "properties": {
        "risk_score": {
          "default": 0.0,
          "description": "Category risk score.",
          "title": "Risk Score",
          "type": "number"
        },
        "receiving_influence": {
          "default": "",
          "description": "Influence of receiving funds from this category.",
          "title": "Receiving Influence",
          "type": "string"
        },
        "sender_influence": {
          "default": "",
          "description": "Influence of sending funds to this category.",
          "title": "Sender Influence",
          "type": "string"
        }
      },
      "title": "RiskInfluence",
      "type": "object"
    },
    "RiskJobState": {
      "description": "Lifecycle state of an analysis job.",
      "enum": [
        "INIT",
        "STARTED",
        "RETRYING",
        "COMPLETED",
        "FAILED"
      ],
      "title": "RiskJobState",
      "type": "string"
    },
    "RiskVolume": {
      "description": "Source/destination volume totals in satoshis and USD.",
      "properties": {
        "source_sats": {
          "default": 0.0,
          "description": "Received (source) volume in sats.",
          "title": "Source Sats",
          "type": "number"
        },
        "destination_sats": {
          "default": 0.0,
          "description": "Sent (destination) volume in sats.",
          "title": "Destination Sats",
          "type": "number"
        },
        "source_usd": {
          "default": 0.0,
          "description": "Received (source) volume in USD.",
          "title": "Source Usd",
          "type": "number"
        },
        "destination_usd": {
          "default": 0.0,
          "description": "Sent (destination) volume in USD.",
          "title": "Destination Usd",
          "type": "number"
        }
      },
      "title": "RiskVolume",
      "type": "object"
    }
  },
  "description": "An address-analysis job. `result` is set once `state` is COMPLETED.",
  "properties": {
    "job_id": {
      "default": "",
      "title": "Job Id",
      "type": "string"
    },
    "state": {
      "$ref": "#/$defs/RiskJobState",
      "default": "INIT"
    },
    "next_update_time": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "UNIX timestamp suggesting when to poll next; null when terminal.",
      "title": "Next Update Time"
    },
    "created_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Created At"
    },
    "started_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Started At"
    },
    "finished_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Finished At"
    },
    "error_message": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Failure detail, set when state is FAILED.",
      "title": "Error Message"
    },
    "result": {
      "anyOf": [
        {
          "$ref": "#/$defs/AddressRiskResult"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    }
  },
  "title": "AddressRiskJob",
  "type": "object"
}

score_tx_address

Risk-score a Bitcoin address in the context of one transaction. Args: tx: Transaction id the address takes part in. address: Bitcoin address to analyze within `tx`. address_side: "withdrawal" if the address is sending funds (analyze the transaction's destinations) or "deposit" if it is receiving funds (analyze the transaction's sources). ai_confidence_threshold: Enable AI-inferred labels at this minimum confidence ("low", "medium", "high"). Omit to disable AI analysis. Returns: A terminal risk job; see `score_address` for the lifecycle. When "COMPLETED" the `result` holds the transaction-specific risk result (`risk_score`, fund tracing, and counterparties). If the job is still pending after SCOREMYCRYPTO_MAX_WAIT, the tool times out and the reserved credit is refunded.

argument	type	required
`tx`	`string`	yes
`address`	`string`	yes
`address_side`	`string`	yes
`ai_confidence_threshold`	`string \| null`	no

Returns: TransactionRiskJob

output schema

{
  "$defs": {
    "AIConfidence": {
      "description": "Categorical confidence level of an AI/ML prediction.",
      "enum": [
        "LOW",
        "MED",
        "HIGH"
      ],
      "title": "AIConfidence",
      "type": "string"
    },
    "AddressTxSide": {
      "description": "Which side of a transaction the analyzed address is on.",
      "enum": [
        "deposit",
        "withdrawal"
      ],
      "title": "AddressTxSide",
      "type": "string"
    },
    "Counterparty": {
      "description": "An entity on the other side of an address's fund flows.\n\nLabeled entities carry `name`/`category`; AI-inferred counterparties also\ncarry `probability`/`confidence`.",
      "properties": {
        "address": {
          "default": "",
          "description": "Bitcoin address of the counterparty.",
          "title": "Address",
          "type": "string"
        },
        "source": {
          "anyOf": [
            {
              "additionalProperties": {
                "$ref": "#/$defs/FundAllocation"
              },
              "type": "object"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Where this counterparty received funds from, by category.",
          "title": "Source"
        },
        "destination": {
          "anyOf": [
            {
              "additionalProperties": {
                "$ref": "#/$defs/FundAllocation"
              },
              "type": "object"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Where this counterparty sent funds to, by category.",
          "title": "Destination"
        },
        "received_amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Total USD received externally by the cluster/address.",
          "title": "Received Amount Usd"
        },
        "sent_amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Total USD sent externally by the cluster/address.",
          "title": "Sent Amount Usd"
        },
        "name": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Identified entity name, if labeled.",
          "title": "Name"
        },
        "category": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Entity category, if labeled.",
          "title": "Category"
        },
        "probability": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "ML probability (0-1), AI-inferred counterparties only.",
          "title": "Probability"
        },
        "confidence": {
          "anyOf": [
            {
              "$ref": "#/$defs/AIConfidence"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Confidence level, AI-inferred counterparties only."
        }
      },
      "title": "Counterparty",
      "type": "object"
    },
    "FundAllocation": {
      "description": "A fund-flow allocation for one entity category.\n\n`percentage` is always present. The amount/distance fields are present for\ndetailed allocations and omitted for percentage-only ones.",
      "properties": {
        "percentage": {
          "default": 0.0,
          "description": "Share of the flow (0-1).",
          "title": "Percentage",
          "type": "number"
        },
        "min_distance": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Fewest hops between the address and this category.",
          "title": "Min Distance"
        },
        "amount_usd": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Allocation amount in USD.",
          "title": "Amount Usd"
        },
        "amount_sats": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Allocation amount in satoshis.",
          "title": "Amount Sats"
        }
      },
      "title": "FundAllocation",
      "type": "object"
    },
    "RiskInfluence": {
      "description": "How one risk category contributes to the overall score.",
      "properties": {
        "risk_score": {
          "default": 0.0,
          "description": "Category risk score.",
          "title": "Risk Score",
          "type": "number"
        },
        "receiving_influence": {
          "default": "",
          "description": "Influence of receiving funds from this category.",
          "title": "Receiving Influence",
          "type": "string"
        },
        "sender_influence": {
          "default": "",
          "description": "Influence of sending funds to this category.",
          "title": "Sender Influence",
          "type": "string"
        }
      },
      "title": "RiskInfluence",
      "type": "object"
    },
    "RiskJobState": {
      "description": "Lifecycle state of an analysis job.",
      "enum": [
        "INIT",
        "STARTED",
        "RETRYING",
        "COMPLETED",
        "FAILED"
      ],
      "title": "RiskJobState",
      "type": "string"
    },
    "TransactionRiskResult": {
      "description": "Risk assessment of an address within the context of one transaction.",
      "properties": {
        "tx": {
          "default": "",
          "description": "Transaction id.",
          "title": "Tx",
          "type": "string"
        },
        "address": {
          "default": "",
          "description": "Analyzed Bitcoin address.",
          "title": "Address",
          "type": "string"
        },
        "side": {
          "anyOf": [
            {
              "$ref": "#/$defs/AddressTxSide"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "amount": {
          "default": 0,
          "description": "Amount attributed to the address, in sats.",
          "title": "Amount",
          "type": "integer"
        },
        "amount_usd": {
          "default": 0.0,
          "description": "Attributed amount in USD.",
          "title": "Amount Usd",
          "type": "number"
        },
        "risk_score": {
          "default": 0.0,
          "description": "Transaction-specific risk score.",
          "title": "Risk Score",
          "type": "number"
        },
        "funds": {
          "additionalProperties": {
            "$ref": "#/$defs/FundAllocation"
          },
          "description": "Traced funds by entity category.",
          "title": "Funds",
          "type": "object"
        },
        "include_ai_inferred_labels": {
          "default": false,
          "title": "Include Ai Inferred Labels",
          "type": "boolean"
        },
        "ai_confidence_threshold": {
          "anyOf": [
            {
              "$ref": "#/$defs/AIConfidence"
            },
            {
              "type": "null"
            }
          ],
          "default": null
        },
        "counterparty": {
          "description": "Counterparties on the other side of the tx.",
          "items": {
            "$ref": "#/$defs/Counterparty"
          },
          "title": "Counterparty",
          "type": "array"
        },
        "ai_inferred_counterparty": {
          "items": {
            "$ref": "#/$defs/Counterparty"
          },
          "title": "Ai Inferred Counterparty",
          "type": "array"
        },
        "risk_profile": {
          "additionalProperties": {
            "$ref": "#/$defs/RiskInfluence"
          },
          "title": "Risk Profile",
          "type": "object"
        },
        "risky_volume_sats": {
          "default": 0.0,
          "title": "Risky Volume Sats",
          "type": "number"
        },
        "risky_volume_usd": {
          "default": 0.0,
          "title": "Risky Volume Usd",
          "type": "number"
        },
        "run_at_block_height": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "title": "Run At Block Height"
        },
        "has_blacklist_flag": {
          "default": false,
          "title": "Has Blacklist Flag",
          "type": "boolean"
        },
        "api_version": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "title": "Api Version"
        }
      },
      "title": "TransactionRiskResult",
      "type": "object"
    }
  },
  "description": "A transaction-analysis job. `result` is set once `state` is COMPLETED.",
  "properties": {
    "job_id": {
      "default": "",
      "title": "Job Id",
      "type": "string"
    },
    "state": {
      "$ref": "#/$defs/RiskJobState",
      "default": "INIT"
    },
    "next_update_time": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "UNIX timestamp suggesting when to poll next; null when terminal.",
      "title": "Next Update Time"
    },
    "created_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Created At"
    },
    "started_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Started At"
    },
    "finished_at": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Finished At"
    },
    "error_message": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Failure detail, set when state is FAILED.",
      "title": "Error Message"
    },
    "result": {
      "anyOf": [
        {
          "$ref": "#/$defs/TransactionRiskResult"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    }
  },
  "title": "TransactionRiskJob",
  "type": "object"
}

Payments & credits (3)

buy_credits

Create a PaidlyInteractive checkout invoice for this bearer token. Each credit currently costs PRICE_SATS_PER_CREDIT, defaulting to 99 sats. The returned bolt11_invoice should be paid by the user. Credits are applied when the invoice settles via webhook; use check_payment to poll.

argument	type	required	description
`credit_count`	`integer`	no

Returns: buy_creditsDictOutput

output schema

{
  "additionalProperties": true,
  "title": "buy_creditsDictOutput",
  "type": "object"
}

check_payment

Poll PaidlyInteractive for one of this token's invoices.

argument	type	required	description
`invoice_id`	`string`	yes

Returns: check_paymentDictOutput

output schema

{
  "additionalProperties": true,
  "title": "check_paymentDictOutput",
  "type": "object"
}

get_balance

Return the current credit balance for the authenticated bearer token.

No arguments.

Returns: get_balanceDictOutput

output schema

{
  "additionalProperties": true,
  "title": "get_balanceDictOutput",
  "type": "object"
}