Skip to main content
Glama
740,967 tools. Updated 2026-11-03 23:43

"Zcash" matching MCP tools:

  • INCOMING Zcash (zec, ZEC, mainnet) outputs for an address — every coin received (tx, amount, output type: payment/change/mining (block reward), time), most recent first. Indexed by address (fast). Use to see what a ZEC address received and in which transactions. NOT what this address spent → use zec_sent_from_address. NOT sums over its whole history → use zec_address_flow_summary or zec_address_profile. An address can receive several coins (outputs) in one transaction, each its own row. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' for the largest receipts instead: a top-N page with no Cursor. NOTE: shows receiving events, not the sender addresses (a UTXO output has no single sender) — pass a Tx to zec_tx_flow to see the addresses that funded it, or call zec_address_flow_summary for the top senders. Coins that arrive from the shielded pool are listed here too: their transaction has no transparent inputs in zec_tx_flow, and where they came from cannot be traced. Only the TRANSPARENT side of Zcash is visible: transparent addresses start with t1 or t3. Coins moved into or out of the shielded pool (z-addresses, unified u1… addresses) cannot be traced here. Each row: Time, Tx, Type, Amount_ZEC, Cursor.
    ConnectorOAuth
  • Creates a payment invoice to add funds to the connected prepaid PikaSim Wallet, and returns a payment page link (the human can pay by card with 3D Secure, or crypto) plus per-coin crypto payment details. Accepts Bitcoin, Lightning, Monero, Zcash, USDT, and 50+ altcoins, or card on the payment page. Does not move funds itself; it returns an invoice the user pays externally, and the balance updates once the payment confirms. Use when check_balance is too low to purchase. Minimum deposit is $1 (no prepaid float required). A fully-autonomous agent holding crypto can pay WITHOUT a human: the tool returns native destinations for Lightning, Bitcoin on-chain, USDT (TRC-20/Tron), and Monero — pay the amount to any one of them. Crypto has no fee; card payments add a 2.9% processing fee on top of the credited amount. Balance is prepaid credit for purchases on PikaSim, never expires, and is not redeemable for cash. Requires a connected agent wallet (OAuth or ak_live_ key).
    ConnectorNo auth
  • Submit a public crypto wallet address (Bitcoin, Ethereum, Solana, stablecoin wallets, and other supported chains) so RealOpen can verify ownership and count its holdings toward a crypto Proof of Funds letter for a real estate purchase. Detects the blockchain, scans on-chain balances, and returns verification options (message signing or dust transfer). Also serves as the retry path: if a previously-added wallet is in a FAILED or unverified state, call this tool again with the same address to get a fresh verification challenge. If the wallet is already verified, the response will indicate that. The response renders an inline Verify Wallet widget showing the verification message (with copy button), the dust-transfer deposit address, and the multi-asset menu; the user clicks through the widget rather than you reading the values aloud. CANCELLED-CALL HANDLING: if a prior invocation of this tool returned no result because the user dismissed or did not approve the client-side consent prompt, simply retry when the user asks again. Do NOT tell the user that the platform or safety checks blocked the action, and do NOT invent a server-side reason — there is no such block on the RealOpen side; it was just a missed consent tap. POST-VERIFY RE-CHECK: the widget runs verify_wallet_signature / verify_wallet_transfer internally via callTool when the user submits from inside it. That silent call does not always produce a visible follow-up in chat — the client can drop the sendFollowUpMessage trigger. If the user says they completed verification, or says the widget shows "verified", or asks to proceed, ALWAYS call get_wallet_summary first to read the fresh ownership_status before answering. Do not tell the user "still not verified" based on your prior tool output — that output is stale the moment the widget is used. PRESENTATION: identify the wallet to the user by its address, never by wallet_id (the UUID is internal — use it only as a parameter to other tools). EVM CHAIN NOTE: 0x... addresses are verified across Ethereum, Base, Arbitrum, BNB Smart Chain, and Ethereum Classic. Signature verification is chain-agnostic and works for any EVM wallet — both regular (EOA) and smart-contract wallets (the verifier checks ERC-1271 on-chain). Dust-transfer verification works on Ethereum, Base, Arbitrum, BNB Smart Chain, and Ethereum Classic too: each dust-transfer option is tagged with its chain (e.g. "USDC on Base", "BNB on BNB Chain", "ETC on Ethereum Classic"), so the user must send on the chain shown for that option. (Polygon is also supported for signature verification.) BNB itself is accepted natively on BNB Smart Chain or as the original ERC-20 on Ethereum — the same 0x deposit address serves both; legacy Beacon Chain (bnb1...) addresses are not supported. ZERO-BALANCE NOTE: If total_usd is 0, do NOT assume the wallet is empty. Many wallets use stealth addresses, HD-derived receive addresses, or UTXO shuffling that hide true balance behind the public address. If the response includes a zero_balance_hint, surface that guidance to the user and strongly suggest the test-transfer verification path. EXCHANGE CUSTODY: if the user's crypto is held on an exchange account (Coinbase, Binance, etc.) — where they cannot sign messages and do not control the sending address — do not force this flow; search get_faq for "exchange" and explain that exchange-held assets are supported via account statements and manual review. ZCASH (ZEC): accepted on TRANSPARENT addresses only (t1…/t3…). Shielded or unified addresses (zs1…/u1…) are rejected with error code shielded_zcash — balances there are private by design and can never be verified. BEFORE a Zcash user starts verification, ask whether their ZEC is on a transparent address; if it is shielded, tell them to move the amount they want to prove to a t-address in the same wallet first (Trezor Suite and Ledger Live show transparent Zcash accounts). Relay transparent_only_hint when present. DOGECOIN (DOGE): D… addresses can verify by signed message ("Dogecoin Signed Message" in Dogecoin Core, Ledger Live, Trezor Suite, Exodus) or by test transfer; 9…/A… multisig addresses use the test transfer. Like Bitcoin, only the verified address is counted until an extended public key is linked (link_wallet_xpub — xpub or dgub). ETHEREUM CLASSIC (ETC): the same 0x address is scanned on Ethereum Classic automatically — no separate add. Verified ETC counts toward Proof of Funds and the RealScore Report, but ETC is NOT a settlement asset: RealOpen does not quote or accept ETC to fund a purchase. Never tell a user they can pay for a home with ETC today — say it counts toward proof of funds and that the closing is funded from an accepted settlement asset.
    ConnectorNo auth
  • Call this whenever the user asks for a wallet summary, wallet list, their wallets, wallet balances, verified holdings, or Proof of Funds ceiling — i.e. how much verified crypto they can show for a real estate offer. Returns all wallets for the authenticated user with their balances, verification status, and Proof of Funds ceiling (the maximum a crypto Proof of Funds letter can state). The response renders an inline Your Wallets widget — each card shows the address (with click-to-copy), chain, verified status, assets, and View details / Verify (if unverified) / Remove controls. Let the widget handle presentation; in your text response just summarize counts and any top-line items (e.g. "You have 3 wallets, 2 verified, POF ceiling $65k"). THREE NUMBERS, DO NOT CONFUSE: (1) pof_ceiling_usd — the ONLY valid maximum for a Proof of Funds letter request; already includes the haircut (0.98× stablecoins, 0.935× volatile) and excludes unverified wallets. (2) total_verified_usd — raw pre-haircut sum of verified wallets; reference for "how much verified crypto do I have" but NEVER offer this as a POF amount — the generator will reject it. (3) Σ wallets[].total_usd — the sum across ALL wallets including unverified; never a valid POF ceiling. When the user asks to generate POF, always suggest amounts at or below pof_ceiling_usd. ETHEREUM CLASSIC: an asset row with chain ethereum-classic (ETC) counts toward pof_ceiling_usd but is not a settlement asset — never offer ETC as a way to fund a purchase. PRESENTATION: always identify wallets to the user by their blockchain address, never by wallet_id. The wallet_id is an internal UUID — use it only as a parameter when calling other tools. LINKED ADDRESSES: a wallet entry may include linked_addresses — additional addresses proven owned via a verification transfer. ZERO-BALANCE NOTE: if a wallet's total_usd is 0 and it is unverified, do NOT imply the wallet is empty. If the response includes a zero_balance_hint for that wallet, surface that guidance verbatim and suggest the test-transfer verification path to reveal linked addresses. BITCOIN FULL-WALLET NOTE: a verified Bitcoin wallet entry may carry full_wallet_hint (no extended public key linked yet — only the verified address and transfer-proven addresses are counted) or xpub_linked: true with an xpub_scan summary (every derived address counted). If a user says their Bitcoin, Zcash or Dogecoin balance looks low, relay full_wallet_hint and offer link_wallet_xpub. ZCASH: a Zcash wallet entry carries transparent_only_hint — only transparent (t1…) balances are verified and counted; relay it before the user starts verification if their ZEC may be shielded. STAKING: assets[] entries may be staking positions (position_type STAKED / LIQUID_STAKING_TOKEN / UNSTAKING / CLAIMABLE / LOCKED with a staking{} block: protocol_label e.g. "Everstake" (the pool Trezor Suite uses), "Lido", status, liquidity, underlying_symbol). They are attributed to the verified wallet and already count toward total_usd and pof_ceiling_usd by their underlying asset (eligible_as), but entries with transferable:false must be UNSTAKED before the funds can be sent — a wallet with staked value also reports liquid_usd / staked_usd and a staking_hint; relay it. Never tell a user to unstake in order to verify a wallet or get a letter; unstaking is needed before closing.
    ConnectorNo auth
  • Get the latest-day net ETF inflow/outflow (USD millions) for every tracked crypto asset: BTC (Bitcoin), ETH (Ethereum), SOL (Solana), XRP, HYP (Hyperliquid), DOGE (Dogecoin), LINK (Chainlink), AVAX (Avalanche), HBAR (Hedera), LTC (Litecoin), BNB, DOT (Polkadot), SUI, NEAR, TRX (TRON) and ZEC (Zcash). Positive = inflow, negative = outflow. Flows are published one business day in arrears, so `referenceIsToday` is normally false: the figures belong to `referenceDate`, the last trading day published, not to the current date. On Mondays the freshest data is Friday's. `totalUsdM` is the sum across all assets for `referenceDate`. `netFlowUsdM` is null for an asset that has no figure for `referenceDate` yet; its latest reported day is then in `lastReportedDate`, and it is not part of `totalUsdM`. Figures are asset-level totals; the per-fund breakdown (IBIT, FBTC, ETHA and others) is returned by get_fund_flows, net assets by get_funds.
    ConnectorNo auth
  • BATCH label lookup for a LIST of addresses — label many wallets, counterparties or holders in ONE call: each labeled address comes back with all its on-chain labels (entity / category / CEX-deposit / mixer / scam / token-clone / …). Use to label any set of addresses you already have — e.g. the counterparties returned by a transfer / flow / holders tool. Those rows carry NO label field on Ethereum, BSC, Polygon, Arbitrum, Base, Optimism, Tron, the XRP Ledger, Stellar or Cardano, so this call is the step that identifies them. Only the Solana rows and the Bitcoin-style rows of Bitcoin, Zcash, Litecoin, Dogecoin, Dash and Bitcoin Cash have an inline label field at all, and it is SPARSE on Solana and EMPTY on all the others (the inline list holds none of their addresses) — batch those addresses into this call; a blank one still needs it. Zcash, Dash, Robinhood and Arc have no label coverage at all. Most Bitcoin Cash entries are stored in the old 1… / 3… address form, so CashAddr (q… / p…) addresses find only a few. Addresses may be separated by commas, pipes, spaces or newlines (any mix), so a counterparty list can be pasted straight from another tool's output. Each label comes back CHAIN-QUALIFIED as chain/label_type:label_value. On EVM chains one address is the same owner everywhere, and a label is stored under the chain it was observed on — so LEAVE chain EMPTY (the default) unless you truly need one chain only; filtering by chain hides an exchange/entity tag that was recorded under a different EVM chain. Sources lists every source behind the address's labels and Source_Count how many there are. Labels that disagree (e.g. cex-deposit-address AND cex-hot-wallet for one exchange) come from different sources: a source whose name contains "heuristic" was inferred from transfer patterns, while sanctions lists, official proof-of-reserves disclosures and verified sources are curated — trust the entity they agree on and prefer the curated role. address_labels shows which source recorded which label. Source names: workflow:<name> is a Bitquery labelling pipeline - curated imports such as sanctions and issuer block lists, proof-of-reserves disclosures, research sets and label-provider enrichment - except that a name containing "heuristic" marks labels inferred from transfer patterns (most exchange-deposit labels); labels-query-service:<provider> was fetched on demand from an outside label provider when the address was looked up (one provider's view, not reviewed); a plain name is the dataset itself (ofac, uk-ofsi, eu-sanctions, japan-mof, france-gels and israel-nbctf are sanctions lists; walletexplorer and bitcoinabuse are public Bitcoin datasets), and a name containing "verified" is a reviewed import. To answer "which TRADERS of token X are labeled (CEX-deposit / mixer / …)", do it in two steps: first call top_traders_by_token (or accumulating_/profitable_traders_by_token) to get the trader addresses, then pass them here and match by address. For ALL labels of ONE address use `address_labels`; to list every address carrying a label use `addresses_by_label`. Only addresses that carry a label come back, and every such row says OK in its Status column — an address missing from the answer carries no label, a meaningful negative. When NONE of the addresses is labeled, the answer is ONE row whose address is empty and whose Status says NO_LABELS_FOUND: the lookup ran and found nothing, the same negative, not a failed call. Coverage varies by chain AND by label kind — exchange deposit / hot-wallet tags are broad on the EVM chains and Tron, mixer tags exist essentially only for Bitcoin, and sanctioned / darknet tags sit mostly on Bitcoin, Tron and Ethereum. So an empty result on a given chain means "not labeled there", not "clean".
    ConnectorOAuth

Matching MCP Servers

Matching MCP Connectors

  • ADDRESS FLOW SUMMARY / top counterparties of a Zcash (zec, ZEC, mainnet) address in one call: who it pays and who pays it, plus its lifetime profile and a computed Role. Call this FIRST when triaging a hop; for raw rows use zec_sent_from_address / zec_address_received, for one transaction zec_tx_flow. NOT only the lifetime totals, without counterparties → use zec_address_profile. PROFILE columns (Lifetime_*, First_Received, Last_Received, Last_Sent) cover the address's WHOLE history. Lifetime_Received_ZEC / Lifetime_Sent_ZEC are cumulative TURNOVER, not holdings: every output ever paid to the address (including the change it pays back to itself inside its own spending transactions) and every input it ever spent. The same coins are counted each time they pass through, so a busy exchange wallet's totals can exceed the coin's total supply many times over; Lifetime_Received minus Lifetime_Sent is the balance at this address. Role covers the WHOLE history too, not the `days` window, and follows from the lifetime counts: no_transfers (nothing received and nothing spent) / receive_only (it never spent anything — cold storage or an unused deposit address) / send_only (spends with no recorded receipt) / hub (more than 1,000 distinct senders AND more than 1,000 distinct receivers — an exchange or service, don't trace deeper) / consolidator (distinct senders more than 3 times distinct receivers) / distributor (distinct receivers more than 3 times distinct senders) / relay (none of these). The TOP ARRAYS cover only the last `days` (default 90) and, inside that window, at most the 1,000 most recent transactions on each side. Spend_Txs_Scanned / Receipt_Txs_Scanned say how many were read; Spend_Txs_Truncated / Receipt_Txs_Truncated = 1 means older transactions in the window were left out. So the arrays do NOT add up to the Lifetime_* totals. Window_Days / Window_From state the period covered: empty arrays for an address whose Last_Sent is long ago mean nothing moved in the window, not that it never moved — raise days. Top_Receivers = the non-change recipients of the transactions this address spent in; Amount = ZEC paid to that recipient. Top_Senders = the input addresses of the transactions that paid this address (change excluded); Amount = ZEC this address received in those transactions. A transaction with several input addresses credits each of them in full (they are usually one owner — see zec_related_addresses), so Amount can be far more than what moved between the two addresses. pro_rata_amount is Amount scaled by the input share: how much of those transactions this address paid (Top_Receivers) or that sender paid (Top_Senders). Both arrays are RANKED by pro_rata_amount, largest first, and min_amount / max_amount filter on it — dust and address-poisoning payments hidden inside a large co-signed transaction have a tiny share. Window_Own_Input_ZEC is what this address itself put into the spending transactions read, the ceiling the Top_Receivers pro-rata amounts add up to. The arrays are built from a copy of the transaction data that misses a few whole blocks (a handful a month), so a counterparty can be absent. READING THE TOP ARRAYS: positional 4-tuples [counterparty, amount, txs, pro_rata_amount]; the Top_Fields column lists those names in the same order. Shielded_Out_ZEC = ZEC the scanned spend transactions moved from the transparent side INTO the shielded pool; Shielded_In_ZEC = ZEC the scanned receipt transactions brought OUT of it (whole-transaction values, same window and cap as the arrays; block rewards are not counted). Shielded_In_ZEC is exact. Shielded_Out_ZEC is exact for the Sapling pool and an estimate for the Orchard pool, where the shielded amount and the fee are not recorded separately: a standard fee is subtracted per transaction, so an unusually high fee can add up to a few hundredths of a ZEC per transaction. Shielded value cannot be followed: a large Shielded_Out_ZEC with few or no Top_Receivers means the coins went into the shielded pool (the visible trail ends there), and a receipt funded from the shielded pool has no visible sender. Only the TRANSPARENT side of Zcash is visible: transparent addresses start with t1 or t3. Coins moved into or out of the shielded pool (z-addresses, unified u1… addresses) cannot be traced here. Address labels are not available for this chain, so exchange / mixer / service nodes cannot be recognized from this data.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Zcash (zec, ZEC, mainnet) address: Source → Target (real recipients of the address's spends, excluding change), total Amount (ZEC). Building block for a MoneyFlow DIAGRAM — call per address/hop, collect edges, render Mermaid `graph LR`. Merge same-owner Targets via zec_related_addresses. NOT one transaction's outputs → use zec_tx_flow. NOT its spending transactions one by one → use zec_sent_from_address. Returns up to limit rows (default 20, at most 1000), one per recipient of its spends. Only the scope row (empty Target) for an address that does spend means the coins of the transactions read went into the shielded pool: the visible trail ends there (zec_address_flow_summary reports how much). Only the TRANSPARENT side of Zcash is visible: transparent addresses start with t1 or t3. Coins moved into or out of the shielded pool (z-addresses, unified u1… addresses) cannot be traced here. Address labels are not available for this chain, so exchange / mixer / service nodes cannot be flagged and there is no label-based stop condition. Amount is the FULL value of those outputs; Pro_Rata_Amount is the part of it this address paid for - its own input value divided by the total input value of the same transaction. When the address signs a transaction together with other addresses, every output of it is credited to each of them in full, so Amount can be many times the money this address ever moved (over a hundred times on an address that keeps co-signing with a large wallet). The rows are therefore RANKED by Pro_Rata_Amount, and that is the figure to add up or to compare between Targets. Own_Input_ZEC on every row is what the address itself put into the transactions read: the Pro_Rata_Amount of all its edges adds up to at most that, the rest being fees and change it paid back to itself. SCOPE: reads the address's most recent max_txs spending transactions (default 1000, at most 2000); Amount, Pro_Rata_Amount and Txs cover those transactions only. Two scope columns on every row state what was covered: how many of those transactions were read and the time of the oldest one. Next_Cursor is set whenever the batch was full, so older transactions may exist - pass it as cursor (same address and max_txs) to continue with the next older batch; an empty Next_Cursor means the history ends here. The outputs of those transactions come from a copy of the transaction data that misses a few whole blocks (a handful a month), so an edge can be absent; zec_tx_flow and zec_sent_from_address read the complete data. When nothing matched in the transactions read, ONE row comes back with an empty Target that carries only these scope columns - that means no edge in this batch, not in the whole history. Each row: Source, Target, Currency, Amount, Pro_Rata_Amount, Txs, Own_Input_ZEC, Spend_Txs_Scanned, Oldest_Spend_Time, Next_Cursor.
    ConnectorOAuth
  • LIKELY SAME-OWNER Zcash (zec, ZEC, mainnet) addresses (common-input-ownership heuristic): addresses that co-signed inputs together with this address in the same transactions — a strong signal they belong to the same wallet/entity. NOT the addresses it paid → use zec_flow_edges. Shared_Txs is how many txs they co-spent in, Co_Input_ZEC the co-input volume. Returns up to limit rows (default 20, at most 1000), most Shared_Txs first. Use to expand an address into its cluster during tracing. CAVEAT: CoinJoin/mixer txs break the heuristic (false positives) — treat high-fan-in shared txs with caution. A shared input is evidence of one owner, not proof. SCOPE: reads the address's most recent max_txs spending transactions (default 1000, at most 2000). Two scope columns on every row state what was covered: how many of those transactions were read and the time of the oldest one. Next_Cursor is set whenever the batch was full, so older transactions may exist - pass it as cursor (same address and max_txs) to continue with the next older batch; an empty Next_Cursor means the history ends here. The inputs of those transactions come from a copy of the transaction data that misses a few whole blocks (a handful a month), so a transaction counted in Spend_Txs_Scanned can contribute no related address; zec_tx_flow and zec_sent_from_address read the complete data. When nothing matched in the transactions read, ONE row comes back with an empty Related_Address that carries only these scope columns - that means nothing in this batch, not in the whole history. Address labels are not available for this chain, so exchange / mixer / service nodes cannot be recognized from this data. Each row: Related_Address, Shared_Txs, Co_Input_ZEC, Spend_Txs_Scanned, Oldest_Spend_Time, Next_Cursor.
    ConnectorOAuth
  • OUTGOING Zcash (zec, ZEC, mainnet) — transactions where this address SPENT coins (its inputs): tx, amount, time, and the prior tx that funded each input. Indexed by address (fast). NOT what this address received → use zec_address_received. Page back through history with cursor: pass the Cursor value of the LAST row of a page to get the next one — unlike before_time it never skips rows that share a timestamp (a busy address can spend hundreds of inputs in the same second). Set sort='amount' to surface the largest spends instead of the newest. To see WHERE the funds went, take a Spend_Tx and call zec_tx_flow — its non-change outputs are the recipients. A spend that moved the coins into the shielded pool has no transparent recipient in zec_tx_flow — that is where the visible trail ends.
    ConnectorOAuth
  • LAST RESORT — arbitrary READ-ONLY SQL against the Zcash transfers data (transparent side only). The zec_* tools are the PRIORITY; use this ONLY when none of them can answer. No query optimizer here: filter on the per-key tables and NEVER JOIN big tables (use `IN (SELECT …)`, the only way to "follow" across txs). Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home This data runs on an older release of the engine: some functions and syntax in that reference (map() and toJSONString() among them) do not exist here — when a statement is refused for an unknown function or setting, use the forms shown in this description. ALWAYS query the `_storage` tables of db `zcash` — the same names without `_storage` are far slower and may time out: `zcash.inputs_by_address_storage` / `outputs_by_address_storage` (by address), `zcash.inputs_by_tx_storage` (by tx; cols address, tx_id_bin, value, output_tx_id_bin, output_index) / `outputs_by_tx_storage` (by tx; cols address, tx_id_bin, output_index, value and direction, an Enum unknown/not_change/change/likely_not_change/likely_change/mining/fee), `zcash.transactions_storage` (one row per tx: input_value, output_value, fee_value, is_coinbase, shielded_balance). `shielded_balance` covers the Sapling and Sprout pools only (< 0 = moved INTO the pool, > 0 = came out of it); Orchard transfers are not in it: coins shielded into Orchard show up in `fee_value` (= greatest(input_value - output_value + shielded_balance, 0)), so a "fee" far above ~0.001 ZEC is shielded value, and output_value > input_value on a non-coinbase tx is value that came out of a shielded pool. Db `zcash_flow`: address_transfers (by address; AggregateFunction → -Merge; its count / sum totals are inflated by duplicated rows — take totals from the `_storage` tables), outputs_to_address (by address), tx_inputs / tx_outputs (by block, tx_index). outputs_to_address and tx_outputs OMIT every output of a transaction that has no transparent inputs (all coins coming out of the shielded pool); tx_inputs / tx_outputs hold duplicated rows in some months (use DISTINCT) — prefer the `zcash` `_storage` tables for anything that must be complete. Every table is partitioned by month on `tx_date` — add a `tx_date` bound whenever you can. Addresses & tx ids: `address` is a plain string (t1…/t3…; empty for coinbase inputs and fee rows); `tx_id_bin = unhex('<64hex>')`, output `hex(tx_id_bin)`; `value` is Decimal(18,8), already in ZEC. Date-times come back as 'YYYY-MM-DD hh:mm:ss' UTC; select formatDateTime(tx_time, '%FT%TZ') for ISO-8601 (2026-09-21T15:04:18Z), the shape the other tools return. Shielded (z-address) transfers are not in this data. Address labels are not available for this chain. Read-only; JSONEachRow. A result of more than 25,000 rows is not cut off - the whole query fails with an error - so aggregate (GROUP BY, count) or add a LIMIT of at most 25,000. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x).
    ConnectorOAuth
  • Full flow of one or several Zcash (zec, ZEC, mainnet) transactions: all INPUT addresses (senders) and OUTPUT addresses (receivers) with amounts, each annotated. Note shows change/not_change on outputs — the real payment is the non-change output(s). THE hop primitive for ZEC tracing: follow a non-change recipient to its own spends (zec_sent_from_address) and repeat. tx_hash is the 64-hex id as returned by the other zec tools; pass several ids separated by "|" (up to 50; ids past the 50th are ignored) to expand a batch in one call — the Tx column attributes each row. Side is input, output, fee (the miner fee of the transaction — one row per transaction, 0 on a block reward) or not_found (a requested id that does not exist here — check the id and the chain). Index is the position of the input or output inside the transaction, and Funded_By_Tx on an input row is the transaction that created the coins being spent — pass it back to this tool to trace one hop backwards. An output whose address is also one of the transaction's OWN input addresses is marked change_to_input_address: the wallet paid itself, so it is not a payment to someone else. Only the transparent side of a transaction is shown: when inputs exceed outputs by more than a normal fee the difference went into the shielded pool, and outputs with no inputs came out of it (or are a block reward — its single input has an empty Address). Shielded senders and recipients cannot be traced. The fee row carries that difference too, so on a transaction that moved coins into the shielded pool it is an upper bound on the real fee, not the fee itself. Address labels are not available for this chain, so exchange / mixer / service nodes cannot be recognized from this data.
    ConnectorOAuth
  • WALLET LEDGER of a set of Zcash (zec, ZEC, mainnet) addresses — one row per transaction that touches the client's addresses, NETTED over the whole set: what the set received, what it spent and the difference, so change paid back to one of the client's own addresses is neither income nor a payment. Built for accounting and tax ledgers, wallet statements and reconciliation. NOT one address's raw outputs or inputs — use zec_address_received / zec_sent_from_address; NOT the addresses inside one transaction — use zec_tx_flow. Pass EVERY address of the wallet in `addresses` (up to 50 per call). Netting covers only the addresses passed: an address of the same wallet that is left out looks like an outside party — its change shows as a payment out and its inputs as someone else's (Fee_Shared = 1 is the usual sign). zec_related_addresses suggests addresses that sign together with a known one. Direction: in (the set funded no input — a receipt), out (the set funded inputs and at least one output went elsewhere), self (the set funded inputs and every output came back to it — a consolidation or an internal move, only the fee left). Net_ZEC = Received_ZEC − Spent_ZEC, negative on a payment; on an outgoing payment the amount that went to others is −Net − Fee_Paid. On a transaction funded together with other addresses (Fee_Shared = 1) Net can be positive although Direction is out or self — read the sign of Net. Received_Raw / Spent_Raw / Net_Raw / Fee_Raw / Fee_Paid_Raw are the same amounts as exact integer strings in the smallest unit (1 ZEC = 100,000,000 units) — use them when every digit matters; the decimal columns are JSON numbers. Fee_ZEC is the miner fee of the whole transaction. Fee_Paid_ZEC is the set's part of it: all of it when the set funded every input, nothing when it funded none (a receipt costs the receiver no fee), and — when other addresses funded inputs too (Fee_Shared = 1) — the fee split by input value (fee × spent ÷ all inputs, rounded half up to the smallest unit), Input_Share being the set's share of the transaction's inputs; what the other parties paid is Fee − Fee_Paid. A shared fee is an estimate: either addresses of the wallet are missing from `addresses`, or several parties built the transaction together. Is_Coinbase = 1 marks a block reward (newly mined coins). Only the TRANSPARENT side of Zcash is netted: transparent addresses start with t1 or t3. Tx_From_Shielded_ZEC is the ZEC the whole transaction brought OUT of a shielded pool and Tx_To_Shielded_ZEC the ZEC it moved INTO one (whole-transaction values; the second is an estimate when the pool does not record the amount). A receipt with Tx_From_Shielded_ZEC above 0 came from a shielded sender that cannot be traced; a spend whose transparent outputs all return to the set while Tx_To_Shielded_ZEC is above 0 is an out, not a self — the rest went into the shielded pool, where the trail ends. Fee_Status: exact; upper_bound (the transaction may have moved value into a shielded pool that does not record the amount separately from the fee — the fee columns are null and Fee_Upper_Bound_ZEC is the most the fee can be, usually far more than the real fee); unknown (the transaction took value out of such a pool, so its fee is not visible and the fee columns are null). Price_Usd is the USD price of ZEC at the start of the transaction's hour (hourly market data). Value_Usd = Net × Price_Usd, signed like Net, and Fee_Usd = Fee_Paid × Price_Usd. Price_Status: ok; no_price (no market price for that hour — the newest hour or two have none yet — Price_Usd and the USD columns are null, never a guess and never today's price); suspect (the price is more than twice, or less than half, the price one day earlier AND one day later — a likely data glitch, so Value_Usd and Fee_Usd are left empty). Rows come newest first in block order (Block, then Tx_Index). The window is the last `days` (default 365), or after_time … before_time for a fixed period such as a tax year. Page with cursor: pass the Cursor of the LAST row, with every other argument unchanged, to get the next older page. after_time and before_time bound every page, so no page leaves the period. With after_time set, a page shorter than `limit` is the end of the period; without it each page looks `days` back from its cursor, so a walk continues into older history until a page comes back short. Addresses_Requested / Addresses_Used on every row say how many distinct addresses were passed and how many were read. No rows = no transaction of these addresses in the window. Counterparties are not listed: pass a Tx to zec_tx_flow. SCAN COST grows with the window and with the number of addresses, not with limit: prefer a fixed period to a very large `days`. A window in which the addresses have more than 200,000 inputs or outputs (an exchange-size address) is refused — narrow it.
    ConnectorOAuth
  • Bitcoin fee rates for confirmation targets, plus the mempool floor. When to use: pricing a Bitcoin transaction, or deciding when a sweep will confirm cheaply. Do not use: to measure backlog depth (that is btc_get_mempool_state). There is no equivalent for Zcash: ZEC fees are protocol-fixed, see robotbase_capabilities. Returns: estimates for 1/2/3/6/12/24-block targets in BTC/kvB, recommended.fast_1_block_sat_vb / medium_3_block_sat_vb / slow_12_block_sat_vb, mempool_min_sat_vb.
    ConnectorNo auth
  • Zcash network and node state: mempool size and bytes, node version, difficulty, network hashrate, chain progress and disk, block subsidy, and the funding streams (including Zcash Community Grants). When to use: macro questions about Zcash - how much hashrate secures it, whether our node is caught up, what the block subsidy and funding allocations currently are. Do not use: for shielded-pool supplies (zec_get_pool_status) or our node's own sync state (zec_get_pool_status / chain_status). Returns: mempool, network, difficulty, network_hashrate_hs, blockchain, height, verification_progress, size_on_disk_gb, block_reward_zec, funding_streams[], lockbox_streams[].
    ConnectorNo auth
  • Bitcoin fee rates for confirmation targets, plus the mempool floor. When to use: pricing a Bitcoin transaction, or deciding when a sweep will confirm cheaply. Do not use: to measure backlog depth (that is btc_get_mempool_state). There is no equivalent for Zcash: ZEC fees are protocol-fixed, see robotbase_capabilities. Returns: estimates for 1/2/3/6/12/24-block targets in BTC/kvB, recommended.fast_1_block_sat_vb / medium_3_block_sat_vb / slow_12_block_sat_vb, mempool_min_sat_vb.
    ConnectorNo auth
  • Zcash network and node state: mempool size and bytes, node version, difficulty, network hashrate, chain progress and disk, block subsidy, and the funding streams (including Zcash Community Grants). When to use: macro questions about Zcash - how much hashrate secures it, whether our node is caught up, what the block subsidy and funding allocations currently are. Do not use: for shielded-pool supplies (zec_get_pool_status) or our node's own sync state (zec_get_pool_status / chain_status). Returns: mempool, network, difficulty, network_hashrate_hs, blockchain, height, verification_progress, size_on_disk_gb, block_reward_zec, funding_streams[], lockbox_streams[].
    ConnectorNo auth
  • BITCOIN, ZCASH (transparent) AND DOGECOIN ONLY. Link (or remove) the extended PUBLIC key (xpub / ypub / zpub, or dgub for Dogecoin) of a VERIFIED Bitcoin, Zcash or Dogecoin wallet so every address in that wallet account — receive and change — counts toward the user's balance and Proof of Funds ceiling, not just the single verified address. Use when a verified BTC wallet shows less than the user expects, when get_wallet_summary or refresh_wallet_balance returns full_wallet_hint, or when the user mentions a hardware wallet (Ledger, Trezor, Coldcard) or an HD wallet (Sparrow, BlueWallet, Electrum). The wallet can be verified OR not yet verified. Verified: the key is accepted only if the verified address derives from it (status=linked, binding=active). Not yet verified: the key is stored pending (status=pending_verification, binding=pending) and activates automatically once the wallet is verified — the user then signs with the wallet's address or sends the test transfer from ANY address in that account; nothing counts toward Proof of Funds until then. Offer this right after add_wallet for Bitcoin/Zcash users who mention a hardware or HD wallet, so the whole account counts the moment they verify. WHERE TO FIND IT (tell the user; common wallets, NOT an exhaustive list): Ledger Live → Account → ⋯ → Edit account → Advanced → xpub; Trezor Suite → Account → ⋯ → Show public key; Sparrow → Settings → Keystore; BlueWallet → ⋯ → Export/Backup → Show XPUB; Electrum → Wallet → Information; Exodus (Desktop only) → open the asset → ⋯ → Export XPub (saved to Desktop/exodus-exports). Any other wallet: look for 'export xpub', 'extended/account public key' or 'master public key' in its settings. Ledger, Trezor and Exodus show one key per account — it must be the account holding the verified address. Exodus has no user-facing sign-message feature for Bitcoin or Zcash, so Exodus users verify via the test transfer, then link the xpub. SAFETY: NEVER ask for, accept, or repeat a PRIVATE key (xprv / yprv / zprv) or a seed phrase. If the user pastes one, do not forward it — tell them to treat it as compromised and move funds. An extended PUBLIC key cannot move funds but does reveal the account's addresses and balances; the user should share it only for this purpose. On success, present total_btc / total_usd and funded_address_count from xpub_scan and note that future refreshes rescan the account automatically. If the response error says the verified address is not derived from the key (binding failure), the user most likely exported a different account — ask them to check. Pass unlink: true to remove a previously linked key. MULTISIG (Bitcoin only): a multisig wallet (Sparrow/Nunchuk/Unchained/Casa-style k-of-n) has no single xpub — pass its output descriptor or Unchained wallet config instead; RealOpen derives every receive/change address of the multisig account. Multisig addresses cannot sign messages, so the wallet is verified by the test transfer (verify_wallet_transfer) and the descriptor binds to that transfer's input address; it can be attached before verification (pending) exactly like an xpub.
    Connector
    Destructive
    No auth
  • Answers which cryptocurrencies and chains can pay an OpenRouter credit top-up or another AI service invoice through Rozo Checkout: USDC and USDT on Ethereum, BNB Chain, Polygon, Arbitrum and Solana; USDC on Base and Stellar; native ETH (Ethereum, Base, Arbitrum), BNB, POL and SOL; BTC over Lightning. Returns each chain id, token symbol and token decimals. Static list, needs no payment link and makes no network call; quote_invoice reports which of these a specific invoice accepts. Native coins (ETH on Ethereum, Base, Arbitrum; BNB on BNB Chain; POL on Polygon; SOL on Solana) are exact-out like Lightning: the order states the exact coin amount, priced at the current rate plus an FX spread on top of the service fee, and that price holds only until quoteExpiresAt. Native orders are capped at $3500 per invoice (native ETH on Ethereum needs at least $1), and a native coin is offered only when quote_invoice lists it for that invoice. ZEC on Zcash (Beta) is not available through this server: send a payer holding ZEC to https://checkout.rozo.ai/zec.
    ConnectorNo auth
  • Look up all known LABELS for a blockchain ADDRESS — entity, category, CEX deposit/hot wallet, mixer, gambling, scam, token-clone, contract type, NFT collection, ENS, … Works for both wallets and token/contract addresses. Use for "what / who is this address", "is this token a scam or a clone", "is this wallet a CEX or mixer". To label MANY addresses at once use `labels_for_addresses`; to list every address carrying a label use `addresses_by_label`; to resolve a human name to a stored value use `find_label_values`. Backed by the Bitquery address-label directory (directory.labels). Coverage: token/contract labels are dense on EVM (Ethereum, BSC, Polygon); exchange deposit / hot-wallet labels are broad on the EVM chains and Tron; wallet (EOA) labels are densest on Tron and Bitcoin; mixer labels exist essentially only for Bitcoin, and sanctioned / darknet tags sit mostly on Bitcoin, Tron and Ethereum. Pass chain='' (the default) to search every chain — recommended on EVM, where one address is the same owner on every chain and its label may be stored under a different one. Tracing note: MOST tracing rows carry NO label field, so this call is what puts a name on a counterparty. On Ethereum, BSC, Polygon, Arbitrum, Base, Optimism, Tron, the XRP Ledger, Stellar and Cardano NONE of the transfer / flow tools return a label — always look the address up here (or pass the whole counterparty list to `labels_for_addresses`). Only the Solana tools (address_flow_summary, flow_edges, trace_next_hop, transfers_in/out) and the Bitcoin-style tools of Bitcoin, Zcash, Litecoin, Dogecoin, Dash and Bitcoin Cash (address_profile, address_flow_summary, flow_edges, related_addresses, tx_flow) carry an inline label field at all, and even there it is SPARSE on Solana and EMPTY on every other chain (the inline list holds none of their addresses — batch those addresses into labels_for_addresses) — never treat a blank inline label as "unlabeled", always confirm it here. On the XRP Ledger (chain='ripple'), Cardano (chain='cardano'), Stellar (chain='stellar'), Litecoin (chain='litecoin') and Bitcoin Cash (chain='bitcoin-cash') the directory is sparse, mostly exchange reserve wallets; Dogecoin (chain='dogecoin') holds about 40,000 addresses, almost all exchange reserve wallets. Most Bitcoin Cash entries are stored in the old 1… / 3… address form, so a CashAddr (q… / p…) lookup finds only a few of them. Robinhood, Zcash, Dash and Arc have no label coverage at all, so an empty result there is a coverage gap, not a finding. An empty result while find_label_values shows rich coverage (e.g. 'binance') is a meaningful NEGATIVE signal, not missing data. One row per chain + label_type + label_value; recorded_at is the newest record of it. Several sources can record labels for one address. Rows that agree are merged: Sources lists every source behind a label and Source_Count how many there are. Labels that disagree stay separate — typically the same entity in different roles, e.g. cex-deposit-address AND cex-hot-wallet for one exchange, or a token-contract next to a token-clone. Such a conflict comes from different sources; weigh it by Source_Count and by the kind of source: sanctions lists (ofac, uk-ofsi, eu-sanctions …), official proof-of-reserves disclosures and verified sources are curated, while a source whose name contains "heuristic" was inferred from transfer patterns (broad, less certain) — trust the entity they agree on, and prefer the curated role when they differ. Source names: workflow:<name> is a Bitquery labelling pipeline - curated imports such as sanctions and issuer block lists, proof-of-reserves disclosures, research sets and label-provider enrichment - except that a name containing "heuristic" marks labels inferred from transfer patterns (most exchange-deposit labels); labels-query-service:<provider> was fetched on demand from an outside label provider when the address was looked up (one provider's view, not reviewed); a plain name is the dataset itself (ofac, uk-ofsi, eu-sanctions, japan-mof, france-gels and israel-nbctf are sanctions lists; walletexplorer and bitcoinabuse are public Bitcoin datasets), and a name containing "verified" is a reviewed import.
    ConnectorOAuth
  • CATALOG of the databases raw SQL can reach — the SHOW DATABASES equivalent. For each database: what it holds, which tool runs SQL against it, how to see its tables, and which specialized tools answer the same questions without SQL. Call it before writing raw SQL against an unfamiliar database. Takes no parameters and answers instantly. trading_rt comes first: DEX trades, OHLC / volume bars, prices and supply for every trading chain over the last ~30 days — query it with execute_sql, browse it with list_tables, describe_table and search_columns. The per-chain databases (eth_api, bsc_api, matic_api, arbitrum_api, base_api, optimism_api, robinhood_api, arc_api, tron_api, solana, bitcoin, bitcoin_flow, ripple, ripple_flow, cardano, cardano_flow, altcoin, altcoin_flow - Litecoin, Dogecoin and Dash in one database, rows told apart by blockchain_id - bitcash, bitcash_flow for Bitcoin Cash, and stellar) hold transfers, calls, events, transactions and balances; browse them with chain_list_tables, chain_describe_table and chain_search_columns (pass the database name) and query each one with that chain's <chain>_transfers_raw_sql tool (xrp_, ada_, ltc_ / doge_ / dash_, bch_ and xlm_transfers_raw_sql for the ones above after bitcoin_flow). zcash and zcash_flow are queried with zec_transfers_raw_sql but the schema browser does not cover them: that tool's description lists their tables. stellar_flow is not browsable either - it starts in December 2023 and misses some ledgers, so query stellar instead. Address labels have no SQL access at all — use the label tools. Prefer a specialized tool whenever one answers the question: it already filters on the right keys and is far cheaper than hand-written SQL.
    ConnectorOAuth