Skip to content
verify mcp Beta VerifyMCP is currently in beta. If you notice any issues, get in touch and we’ll put it right.

TraceFast

REMOTE · TRACEFAST.XYZ

Ethereum data for agents: blocks, transactions, traces, tokens, and facts about addresses.

Available components

+35 this week 74 Trust /100

Last scanned (17 hours ago)

Scores higher than 60% of remote servers

Reachable. Last reached 21 Nov 2026.

Category Crypto and Web3

Trust breakdown (7 categories)

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. How we score → Why this is hard to score →

Endpoint Security83
  • The endpoint's TLS certificate is valid, in date, and uses a strong key. View diagnostics → Pass
  • No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation. See how to fix → View diagnostics → Partial
  • HTTPS is enforced; there's no plaintext access path. View diagnostics → Pass
  • The HSTS (Strict-Transport-Security) header is present. View diagnostics → Pass
  • DNSSEC is configured correctly; the domain's records validate against the full chain to the root. View diagnostics → Pass
Transport & Reachability100
Schema Quality & AI Usability60
  • AI-judged instruction clarity (excellent).Pass
  • Context-footprint check failed: tool/resource definitions use about 53271 tokens (~484/item across 110 items; 110 tools + 0 resources), over budget; trim descriptions and params. See how to fix → Fail
  • Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management13
  • Stability observed for 4 of 30 days with no destabilising changes; credit accrues until the full window elapses.Partial
Tool Coverage100
  • 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
  • 100% of tool parameters carry a description.Pass
  • Structured output schemas are declared (100% of tools); any adoption earns full credit.Pass
Tool Safety100
  • No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.Pass
  • We read all 110 captured tool definition(s), and no name or description among them implies an irreversible operation.Pass
  • An AI judge read all 111 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities100
  • Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.Pass
What we tested

Checks we ran (13)

  • TLS certificate
  • Authorization
  • HTTPS
  • HSTS header
  • DNSSEC
  • Transport
  • Schema quality
  • Stability
  • Tool coverage
  • Injection markers
  • Destructive annotations
  • Judged manipulation
  • MCP protocol

Does not apply to this hosted endpoint (2)

  • Supply Chain SecurityScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
  • Provenance & TransparencyScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.

The score does not measure everything. What the score does not measure →

Changelog

Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.

  • 21 Nov 26 +1
    • Tool “get_entity_token_transfers” rewrote its description, which is the text the model reads security
    • Server version: 0.2.0+b52148c7 → 0.2.0+1a728c5e functional
    • “get_entity_token_transfers” reworded the description of “counterparty” cosmetic
    • “get_transaction” reworded the description of “includeTokenTransfers” cosmetic
  • 20 Nov 26 0
    • Tool “get_blacklist_issuers” rewrote its description, which is the text the model reads security
    • Tool “get_block_transactions” rewrote its description, which is the text the model reads security
    • Tool “get_contract_decompilation” rewrote its description, which is the text the model reads security
    • Tool “get_contract_function_calls” rewrote its description, which is the text the model reads security
    • Tool “get_contract_selectors” rewrote its description, which is the text the model reads security
    • Tool “get_pools_for_pair” rewrote its description, which is the text the model reads security
    • Tool “get_signal_rates” rewrote its description, which is the text the model reads security
    • Tool “get_token_pools” rewrote its description, which is the text the model reads security
    • Tool “get_top_pools” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_failures” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_liquidity_events” rewrote its description, which is the text the model reads security
    • Tool “resolve_entity” rewrote its description, which is the text the model reads security
    • Server version: 0.2.0+6df1eebb → 0.2.0+b52148c7 functional
    • “get_contract_function_calls” added an optional parameter “cursor” cosmetic
    • “get_contract_selectors” added an optional parameter “cursor” cosmetic
    • “get_pools_for_pair” added an optional parameter “cursor” cosmetic
    • “get_top_pools” added an optional parameter “cursor” cosmetic
    • “get_transaction_liquidity_events” added an optional parameter “cursor” cosmetic
    • “get_entity_transactions” reworded the description of “methodName” cosmetic
    • “get_top_pools” reworded the description of “limit” cosmetic
  • 19 Nov 26 0
    • Tool “get_block_transactions” rewrote its description, which is the text the model reads security
    • Tool “get_contract_events” rewrote its description, which is the text the model reads security
    • Tool “get_entity_counterparties” rewrote its description, which is the text the model reads security
    • Tool “get_entity_internal_transfers” rewrote its description, which is the text the model reads security
    • Tool “get_entity_token_transfers” rewrote its description, which is the text the model reads security
    • Tool “get_entity_transactions” rewrote its description, which is the text the model reads security
    • Tool “get_token_holders” rewrote its description, which is the text the model reads security
    • Tool “get_trace_frames” rewrote its description, which is the text the model reads security
    • Tool “get_transaction” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_events” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_trace” rewrote its description, which is the text the model reads security
    • Server version: 0.2.0+66022eb5 → 0.2.0+6df1eebb functional
    • “get_block_transactions” added an optional parameter “maxValueWei” cosmetic
    • “get_block_transactions” added an optional parameter “methodId” cosmetic
    • “get_block_transactions” added an optional parameter “minValueWei” cosmetic
    • “get_block_transactions” added an optional parameter “sort” cosmetic
    • “get_block_transactions” added an optional parameter “status” cosmetic
    • “get_block_transactions” added an optional parameter “txType” cosmetic
    • “get_entity_counterparties” added an optional parameter “counterparty” cosmetic
    • “get_entity_counterparties” added an optional parameter “cursor” cosmetic
    • “get_entity_counterparties” added an optional parameter “window” cosmetic
    • “get_entity_internal_transfers” added an optional parameter “callType” cosmetic
    • “get_entity_internal_transfers” added an optional parameter “fromTimestamp” cosmetic
    • “get_entity_internal_transfers” added an optional parameter “order” cosmetic
    • “get_entity_internal_transfers” added an optional parameter “toTimestamp” cosmetic
    • “get_entity_token_transfers” added an optional parameter “eventType” cosmetic
    • “get_entity_token_transfers” added an optional parameter “fromTimestamp” cosmetic
    • “get_entity_token_transfers” added an optional parameter “maxValue” cosmetic
    • “get_entity_token_transfers” added an optional parameter “minValue” cosmetic
    • “get_entity_token_transfers” added an optional parameter “order” cosmetic
    • “get_entity_token_transfers” added an optional parameter “toTimestamp” cosmetic
    • “get_entity_token_transfers” added an optional parameter “tokenStandard” cosmetic
    • “get_entity_transactions” added an optional parameter “fromTimestamp” cosmetic
    • “get_entity_transactions” added an optional parameter “maxValueWei” cosmetic
    • “get_entity_transactions” added an optional parameter “methodName” cosmetic
    • “get_entity_transactions” added an optional parameter “minValueWei” cosmetic
    • “get_entity_transactions” added an optional parameter “order” cosmetic
    • “get_entity_transactions” added an optional parameter “toTimestamp” cosmetic
    • “get_token_holders” added an optional parameter “cursor” cosmetic
    • “get_transaction” added an optional parameter “includeTokenTransfers” cosmetic
    • “get_entity_counterparties” reworded the description of “block” cosmetic
    • “get_transaction_trace” reworded the description of “includeCalldata” cosmetic
    • Tool “get_entity_counterparties” changed its title: Top counterparties of an address → Counterparties of an address, ranked cosmetic
  • 18 Nov 26 +1
    • Tool “get_contract_events” rewrote its description, which is the text the model reads security
    • Tool “get_entity_portfolio” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_events” rewrote its description, which is the text the model reads security
    • Tool “get_transaction_storage_writes” rewrote its description, which is the text the model reads security
    • Stability: unverified → 0.03 ▲ functional
    • Server version: 0.2.0+acd465fb → 0.2.0+66022eb5 functional
    • New tool “get_transaction_storage_slots” functional
    • “get_contract_events” added an optional parameter “eventName” cosmetic
    • “get_contract_events” added an optional parameter “order” cosmetic
    • “get_entity_portfolio” added an optional parameter “cursor” cosmetic
  • 17 Nov 26 +33
    • Authorization: pass → partial ▼ security
    • Transport: unverified → pass ▲ security
    • Injection markers: unverified → pass ▲ security
    • First check of Judged manipulation: pass security
    • MCP protocol: unverified → pass ▲ functional
    • Tool coverage: unverified → 100 ▲ functional
    • First check of Schema quality: fail functional
    • First check of Schema quality: excellent functional
    • First check of Destructive annotations: pass functional
    • First check of Schema quality: fail functional
    • First check of Tool coverage: 100 functional
    • First check of Tool coverage: 100 functional
  • 14 Nov 26 39

    First indexed and scored.

Diagnostics

Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.

Captured 21 Nov 2026 · Probed https://tracefast.xyz/mcp

TLS valid

Negotiated TLS 1.3 with TLS_AES_128_GCM_SHA256 .

Subject Issuer Valid from Valid until Key Signature Serial
CN=tracefast.xyz CN=WE1,O=Google Trust Services,C=US 7 Nov 2026 5 Feb 2027 ECDSA 256 ECDSA-SHA256 c750d32056d21ab10e2e76d32bea032d
SANs: tracefast.xyz, docs.tracefast.xyz, *.docs.tracefast.xyz
CN=WE1,O=Google Trust Services,C=US (CA) CN=GTS Root R4,O=Google Trust Services LLC,C=US 13 Dec 2023 20 Feb 2029 ECDSA 256 ECDSA-SHA384 7ff31977972c224a76155d13b6d685e3
CN=GTS Root R4,O=Google Trust Services LLC,C=US (CA) CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa,C=BE 15 Nov 2023 28 Jan 2028 ECDSA 384 SHA256-RSA 7fe530bf331343bedd821610493d8a1b

Background: What to check on a remote MCP endpoint →

DNSSEC secure

Validation of tracefast.xyz. — Secure

Zone DS Keys Algorithms Outcome
. Trust anchor 20326, 38696 8, 8 Verified
xyz. DS published 3599, 18130 8, 8 Verified
tracefast.xyz. DS published 2371 13 Verified
tracefast.xyz. Verified address RRset verified with the apex keys
Authentication No authorisation required

The endpoint answered without asking for a token. Anyone who knows the URL can reach it.

Result No authorisation required
HTTP status 200
Header Value
strict-transport-security max-age=31536000; includeSubDomains; preload
x-content-type-options nosniff

Background: How OAuth 2.1 works in the 2026 MCP spec →

Transports 2 probes
Transport URL Outcome Status Location
streamable-http https://tracefast.xyz/mcp Verified 200
http (plaintext) http://tracefast.xyz/mcp HTTPS enforced 301 https://tracefast.xyz/mcp
MCP tools · 110 exposed · ~52,848 tokens

The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →

Tool Tokens
get_entity_calls_received ~505

Every transaction with a call frame in this address's context — it was called, as the transaction's own target (`transactionTarget`) or from inside another contract, reverted or not, with or without ETH — newest first: the block, the transaction, its sender (`txSender`) and whether it succeeded, how many frames ran in the address's context and how many of them failed, their kinds (`callTypes`) and whether any carried ETH. `txSender` signed the transaction; the direct caller may be a contract it reached. A proxy's frames include the runs of its implementation, so an implementation behind a proxy is not listed for those runs. A contract's own deployment is not a call. Known up to `meta.asOfBlock`, which trails the chain head: an empty list means no call up to that block. Use it to see who uses a contract, internal calls included. Not for the transactions the address itself sent or received at top level: use get_entity_transactions. Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-calls-received

NameTypeReqDescription
addressstringyesThe address, `0x` + 40 hex, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_counterparties ~902

The addresses one address has interacted with most, ranked by successful transactions across top-level transactions (with or without ETH, so a called token contract counts), internal ETH transfers and token Transfer events (as emitted: not checked against a balance change, zero amounts included, so address-poisoning events count) — each with its transaction counts, first and last block of interaction, the surfaces the relation was seen on and the token classes involved — plus `corpus`, how many counterparties the ranking covered. The zero address and the address itself are never ranked. Pass `nextCursor` back as `cursor` to go past the first page: the ranking holds `rankingDepth` counterparties (up to 1 000; 100 at a past block and for the largest addresses) and `rankingTruncated` says whether more rank below; a cursor from before the ranking was recomputed is refused (`invalid_cursor`: start again) — for a window that can happen after about 2 minutes, all-time and past-block cursors last longer. `window` `24h` or `7d` ranks the rolling last 24 hours or 7 days instead of the whole history. With `block`, the ranking as it stood at the end of that block, computed over the whole history up to it. With `counterparty`, the figures of that one pair (in the same window or block) read from the relationship graph — for the largest addresses that is not the daily top list their ranking comes from, so a pair can be newer than its ranking row — or `lookup.found: false`; `lookup.excludedFromRanking` marks the zero address and the address itself. Very large addresses are refused for a past block (a ranking or a pair) or a window with the bound stated (never answered with a narrowed set). Use it to see whom an address interacts with, or whether two addresses interacted; a row is not proof that value moved between the two — check the transfers themselves. Not for declared links such as proxy to implementation: use get_entity_relations. Not for the transactions themselves: use get_…

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
blockinteger–State at the end of this block (everything up to and including it). Absent: the current ranking. Not with `window`.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
counterpartystring–One counterparty, `0x` + 40 hex characters: answers that pair's figures (or `lookup.found: false`) instead of a ranking. Not with `limit` or `cursor`.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
windowstring–`all` (default: the whole history), `24h` or `7d` — the rolling last 24 hours or 7 days, ending at the newest block counted. Not with `block`.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_daily_activity ~339

For each day of a window (`period`: `30d`, `90d` by default, or `365d`), how many blocks changed an address's own account state and what changed — balance, nonce (transactions sent), code, creation — plus the window's active days and total active blocks. Days without activity have no entry. Activity that does not change the address's own state, such as receiving a token or being called, is not counted here. Use it to see how regularly an address acts. Not for when it was first or last active (get_entity_activity) or its balance over time (get_entity_balance_history). Arguments: address; optional period. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-daily-activity

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
periodstring–`30d`, `90d` (default) or `365d`.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_deployments ~495

Every contract creation an address made — each successful CREATE or CREATE2 frame it called — oldest first: the created contract, the block, the transaction, `callType`, the code it deployed (`codeHash`, `isEip1167Proxy`) and the wallet that signed the transaction (`originAddress`). The address is the DIRECT creator: for a factory that is the factory, so a wallet's deployments made through a factory are listed under the factory, not the wallet. A row is a creation event: `outcome` `rolled_back` means a frame above it or the transaction failed and no contract came from it. One address can appear more than once (re-created after self-destruction, or rolled-back attempts). An empty list means no creation is recorded up to `meta.asOfBlock`. Use it to list what a deployer or factory created. Not for one contract's own origin: use get_contract_identity. Arguments: address; optional limit (default 10, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-deployments

NameTypeReqDescription
addressstringyesThe creating address, `0x` + 40 hex, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_dex_trades ~533

The DEX swaps an address sent or received the output of, newest first — the venue (`protocol`, `protocolVersion`), the pool (`poolAddress`, or `poolId` for a pool with no address of its own), the tokens sold and bought with their raw amounts, decimals and self-declared symbols, this address's part (`role`), and `valueUsd`, an estimate at the hour of the trade (`valuedLeg` says which leg; absent when neither can be valued). Coverage is the pools TraceFast has discovered: swaps on other pools are missing, and Balancer V2 swaps (whose event names no trader) are not listed, so an empty list is not proof the address never traded. The address is matched as the swap event's sender or recipient: a trade routed through a contract is listed under that contract. Use it to read an address's trading. Not for its token movements in general: use get_entity_token_transfers. Not for every swap of one pool: use get_pool_swaps. Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-dex-trades

NameTypeReqDescription
addressstringyesThe address, `0x` + 40 hex, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_internal_transfers ~841

The value-carrying calls an address sent or received inside transactions, newest first — each with its position and depth in the call tree, the kind of call, the value moved in wei, the other party and the frame's own outcome. The transaction's own top-level call is not one of these: it is the transaction, listed by get_entity_transactions. `direction` (`sent` or `received`), `counterparty` and `callType` (`call`, `callcode`, `create`, `create2`, `selfdestruct`) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address a filter is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to find ETH an address moved or received through contracts. Not for one transaction's whole call tree: use get_transaction_trace. Arguments: address; optional limit (default 10, at most 100), cursor, direction, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, callType. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/entity-internal-transfers

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
callTypestring–One kind of call, as served in `callType`: `call`, `callcode`, `create`, `create2` or `selfdestruct`.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
counterpartystring–Only rows whose other side is this address (`0x` + 40 hex). A filter like the others: on a very active address it is answered only inside a block window, and the refusal names the window it needs (`f…
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
directionstring–`sent` or `received`.
fromBlockinteger–Inclusive lower block bound.
fromTimestampinteger–Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
orderstring–`desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
toBlockinteger–Inclusive upper block bound.
toTimestampinteger–Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_overview ~345

One address as the chain sees it now: how it exists (an account whose state was touched, or an address only ever mentioned by other operations), whether it holds code, for an account whether it delegates its code with EIP-7702 (`eip7702`: to which contract and since which block), its native ETH balance and nonce, when it was first mentioned and last active, and its direct-transaction counters. No names, labels or prices. An address mentioned nowhere on chain is refused (`not_found`). The starting point for any address: use it first. Not for what the address is (use get_entity_attributes), what it holds (get_entity_portfolio) or who it deals with (get_entity_counterparties). Not for its transactions one by one: use get_entity_transactions. Not for how a contract is built: use get_contract. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_portfolio ~538

What an address holds, valued in USD: its token balances and native ETH, each with the balance, the hourly USD price, the USD value and the share of the total, in descending USD value — plus `totalUsd`, `pricedCount` and `hiddenCount` over the WHOLE holding, not just the rows returned; the pages walk every valued position. A position is listed only when it can be valued; the rest is counted in `hiddenCount`. Token balances are served for the covered tokens (`coveredTokenCount`); a token outside that set is absent, not zero. No NFTs, DeFi positions or pool shares. With `block`, the exact state at the end of that block, priced at that block's hour. Use it to value an address's holdings. Not for one token: use get_entity_token_balance. Not for the ETH balance over time: use get_entity_balance_history. Arguments: address; optional block, limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-portfolio

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
blockinteger–State at the end of this block. Absent: the current state.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_relation_history ~564

Every relation interval an address has held, oldest first (`order` `desc`: newest first) — as the subject (what it pointed at, the default) or as the object (who pointed at it) — each with the blocks it started and ended at. Covers the relation ids listed in `coveredFamilies`; an empty or short timeline says nothing about other relations. A long timeline is paged: pass `nextCursor` back as `cursor` until it is absent. `total` is the length of the whole timeline as the subject; there is none as the object. Use it for "when did this proxy change implementation" or "every delegation this account signed". Not for the relations now: use get_entity_relations. Arguments: address; optional direction, limit (default 25, at most 500), cursor, attributeId, order. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-relation-history

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
attributeIdstring–Only this relation id, for example `relation:eip7702_delegates_to` — every EIP-7702 delegation the account signed, with `total` counting them.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
directionstring–`subject` (default) or `object`.
limitinteger–How many rows to return: 1 to 500, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
orderstring–`asc` (default): oldest interval first. `desc`: newest first — the recent end of a long timeline on the first page.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_relation_proof ~417

The evidence behind one proven relation between two addresses — the facts checked with their expected and observed values, the conditions that had to be false, opaque ids of the sources read, and the block and block hash the evaluation was pinned to. `address` is the relation's subject and `object` the address it points at; `attribute_id` is the relation id (`relation:name`), a get_entity_relations row's `attributeId`. A row listed with `direction` `object` is the other way round: its `counterpart` is the subject, so pass it as `address` and the address you listed as `object`. A relation with no recorded proof is refused (`not_found`). Use it to verify why TraceFast states a relation, such as a proxy's implementation. Not for the relations themselves: use get_entity_relations. Arguments: address, attribute_id, object. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a proof is the record of one evaluation, pinned to the block it read (`data.referenceBlock`); `meta.asOfBlock` is the highest block the proof records reach. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-relation-proof

NameTypeReqDescription
addressstringyesThe subject address, `0x`-prefixed, 40 hex characters, any case.
attribute_idstringyesThe relation id, `relation:name`, as listed by the relations method.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
objectstringyesThe object address of the relation, `0x`-prefixed, 40 hex characters, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_relations ~580

The relations an address holds now — which implementation a proxy points at, which beacon it reads, who administers it, where an account has delegated, which lending market lists a token — as the subject (what it points at, the default) or as the object (who points at it). One hop from this address: to follow a counterpart, call the tool on it. Ordered by relation id, then counterpart. One implementation can be pointed at by millions of proxies, so the first page of the object side also states `counts`: how many addresses point at it per relation id. Use it to find a proxy's implementation, a contract's administrator or an account's delegate. Not for a past block (get_entity_relations_at_block), the timeline (get_entity_relation_history) or interaction partners (get_entity_counterparties). For the evidence behind one relation, use get_entity_relation_proof. Not for a proxy's implementation history as its code and storage show it: use get_contract_proxy. Arguments: address; optional direction, attributeId, limit (default 10, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; each attribute or relation carries the block it was evaluated at, and the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-relations

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
attributeIdstring–Narrow to one relation id, `relation:name`. Any id the graph publishes is accepted.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
directionstring–`subject` (default) or `object`.
limitinteger–How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_relations_at_block ~311

The relations an address was the subject of at the end of one past block — which implementation a proxy pointed at, which beacon it read, who administered it, where an account had delegated — each with the window it held for. Covers the relation ids listed in `coveredFamilies`. Subject side only. Use it for "what did this proxy point at, at block N". Not for the relations now (get_entity_relations) or who pointed at the address (get_entity_relation_history with direction object). Arguments: address, block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the state at the end of the `block` you pass; `meta.asOfBlock` is the highest block the history covers, and a later `block` is refused (`block_not_available`). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-relations-at-block

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
blockintegeryesThe block to answer about. Required.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_state_changes ~458

The history of one account's own state, newest first — one entry per block that changed its balance, nonce or code, with the values before and after the block (`balanceBefore` / `balanceAfter`, nonce, code hash) and whether the account was created in it. The net change over the whole block, not per transaction. A change made by someone else counts too: receiving ETH, a validator withdrawal, being self-destructed into. Known up to `meta.asOfBlock`, which can trail the chain head by a few minutes. Use it to see exactly when and how an account's balance, nonce or code moved. Not for the transactions behind a change (get_entity_transactions) or the ETH balance per day (get_entity_balance_history). Arguments: address; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/entity-state-changes

NameTypeReqDescription
addressstringyesThe account, `0x` + 40 hex, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_token_balance ~359

The balance of one token on one address — what `balanceOf` returns at the end of a block; a balance of "0" is a real zero. Served for the covered tokens (a growing set); another token is refused (`token_not_covered`) rather than answered with a meaningless zero. With `block`, the exact balance then; a pair with no recorded balance at or before it is refused (`balance_not_available`). Use it to read one token's exact balance. Not for everything an address holds (get_entity_portfolio) or a token's largest holders (get_token_holders). Arguments: address, token; optional block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state, or with `block` the state at the end of that block; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/address-token-balance

NameTypeReqDescription
addressstringyesThe holder address, `0x`-prefixed, 40 hex characters, any case.
blockinteger–State at the end of this block. Absent: the current balance.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
tokenstringyesThe token contract address, `0x`-prefixed, 40 hex characters, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_token_transfers ~1,163

The token transfers an address sent or received, newest first — ERC-20, ERC-721 and ERC-1155 transfers and the other value events get_token_transfers lists under `eventType` — each with the token as its contract declares itself (a symbol such as `ETH` or `USDT` is self-declared and may be an imitation: identify the token by its address, and ask resolve_entity whether that address is flagged), the raw amount (not scaled by decimals) or token id, the parties and this address's side (`role`), and the transaction that emitted it with who sent that transaction, which on a router or a batch disburser is another party entirely. A transfer the address made to itself is shown once. `direction` (`sent` or `received`), `token`, `counterparty`, `tokenStandard`, `eventType` and `minValue` / `maxValue` (the raw amount, decimal digits) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address, `tokenStandard` and `eventType` alone are answered without a block window when a page of matches lies near where the list starts (the newest transfers, the oldest under `order` `asc`, or the cursor); any other filter, and those two otherwise, is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to follow an address's token flows. Not for balances (get_entity_portfolio) or one token's transfers across all holders (get_token_transfers). Not for its DEX swaps with a USD value: use get_entity_dex_trades. Arguments: address; optional limit (default 10, at most 100), cursor, direction, token, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, tokenStandard, eventType, minValue, maxValue. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is co…

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
counterpartystring–Only rows whose other side is this address (`0x` + 40 hex). On a very active address it is answered only inside a block window, alone or beside any other filter, and the refusal names the window it n…
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
directionstring–`sent` or `received`.
eventTypestring–One kind of transfer, as served in `eventType`: `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap` or `unwrap`.
fromBlockinteger–Inclusive lower block bound.
fromTimestampinteger–Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
maxValuestring–Inclusive upper bound on the raw amount `value`: decimal digits, up to 2^256 - 1.
minValuestring–Inclusive lower bound on the raw amount `value` (not scaled by decimals): decimal digits, up to 2^256 - 1. A transfer without an amount never matches a value bound.
orderstring–`desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
toBlockinteger–Inclusive upper block bound.
toTimestampinteger–Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.
tokenstring–One token contract, `0x`-prefixed, 40 hex characters.
tokenStandardstring–One token standard: `erc20`, `erc721`, `erc1155`, `erc777` or `erc4626`.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_transactions ~1,007

The transactions an address sent or received, newest first — each with sender, recipient, value, fee, the called function where its selector is known, the outcome, and this address's side (`role`: sender, receiver, or self when it is both). `direction` (`sent` or `received`), `status` (the string "1" for success or "0" for failure), `counterparty`, `methodName` (the called function's name as served, not a selector) and `minValueWei` / `maxValueWei` (wei, at most 38 digits) narrow the list, and `fromBlock` / `toBlock` or `fromTimestamp` / `toTimestamp` (Unix seconds, turned into blocks) bound it; `order` `asc` reads oldest first. On a very active address a filter is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to read an address's own transactions. Not for token movements (get_entity_token_transfers), value moved by inner calls (get_entity_internal_transfers) or who it deals with most (get_entity_counterparties). Not for calls that reached the address from inside other contracts: use get_entity_calls_received. Arguments: address; optional limit (default 10, at most 100), cursor, direction, status, fromBlock, toBlock, counterparty, order, fromTimestamp, toTimestamp, methodName, minValueWei, maxValueWei. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/entity-transactions

NameTypeReqDescription
addressstringyesThe address, `0x`-prefixed, 40 hex characters, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
counterpartystring–Only rows whose other side is this address (`0x` + 40 hex). A filter like the others: on a very active address it is answered only inside a block window, and the refusal names the window it needs (`f…
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
directionstring–`sent` or `received`. Absent: both, with a transaction the address sent to itself shown once.
fromBlockinteger–Inclusive lower block bound.
fromTimestampinteger–Inclusive lower time bound, Unix seconds: rows from the first block at or after this time. Turned into a block bound before the read, so it narrows the walk exactly as `fromBlock` does; with both, th…
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
maxValueWeistring–Inclusive upper bound on `valueWei`: wei, decimal digits, at most 38 digits.
methodNamestring–Only transactions calling the function of this name, exact match (an identifier of at most 128 characters: letters, digits, `_`, `$`), as served in `methodName`. A name, not a 4-byte selector; a tran…
minValueWeistring–Inclusive lower bound on `valueWei`: wei, decimal digits, at most 38 digits.
orderstring–`desc` (default, newest first) or `asc` (oldest first). A cursor continues only in the order it was issued in.
statusstring–`1` success, `0` failure.
toBlockinteger–Inclusive upper block bound.
toTimestampinteger–Inclusive upper time bound, Unix seconds: rows up to the last block at or before this time. Turned into a block bound like `fromTimestamp`; a time after the newest block leaves the top open.

Structured output declared, but exposes no named fields.

No examples provided.

get_entity_validators ~440

The validators that direct their withdrawals to an address, as of the validator snapshot taken about once a day (`snapshotEpoch`): counts over ALL of them whatever `limit` (`validatorCount`, active, withdrawn, slashed, by credential type, and the total effective balance in gwei) and the validators themselves, lowest index first, each with status, slashed, credential type, effective balance and public key. The address is where the payouts GO, not the owner or operator of the validators. An address no validator pays out to answers zeros, a fact as of the snapshot. `truncated` says more validators exist than listed; the list does not continue past the maximum `limit`. Use it to see how much stake pays out to an address. Not for one validator (get_consensus_validator) or the payouts themselves (get_validator_withdrawals). Arguments: address; optional limit (default 25, at most 500). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/entity-validators

NameTypeReqDescription
addressstringyesThe address, `0x` + 40 hex, any case.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
limitinteger–How many rows to return: 1 to 500, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_gas_daily ~384

Per UTC day over a window of dates, oldest first: the effective gas price transactions paid (average, median, 10th and 90th percentile, wei), the priority fee (average and median, wei) and how many transactions there were of each type — legacy, access list (EIP-2930), EIP-1559, blob (EIP-4844) and set-code (EIP-7702). `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart gas prices or the adoption of transaction types. Not for the base fee, block counts and burnt fees (get_network_daily) or blob counts (get_blobs_daily). Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-gas

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
fromstring–The first UTC date, `YYYY-MM-DD`.
tostring–The last UTC date, `YYYY-MM-DD`. Default: today.

Structured output declared, but exposes no named fields.

No examples provided.

get_largest_liquidity_removals ~463

The largest removals of liquidity from DEX pools over a window of blocks ending at `meta.asOfBlock` (`window`: `24h`, `7d` by default, or `30d`; the blocks are echoed as `fromBlock` / `toBlock`), largest USD first — each with the pool, its protocol, the provider the event names, the transaction and block, the event as the pool names it, and how many of its token legs could be priced. Only events with at least one priced leg rank, and `usdRemoved` covers the priced legs only. Uniswap v4 pools are not covered. The top of the ranking only: the maximum `limit` is the deepest it goes. Use it to spot the largest exits of liquidity across all pools. Not for one pool's events over time: use get_pool_liquidity_events. Not for every token leg of one removal: use get_transaction_liquidity_events. Not for one pool's flow day by day: use get_pool_liquidity_flow. Arguments: none required; optional window, limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pools-liquidity-removals

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
windowstring–`24h`, `7d` (default) or `30d`.

Structured output declared, but exposes no named fields.

No examples provided.

get_latest_block ~216

The newest block TraceFast serves, with its header and the totals of what it contains — transaction counts by outcome, gas, fees, value moved, withdrawals. Use it to learn the current height before asking about recent data. Not for a given height: use get_block. Not for the block at a given time: use get_block_at_time. Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the newest block TraceFast serves; `meta.asOfBlock` is its height. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/block-latest

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_lending_market_config ~392

The risk configuration of every asset of a lending protocol's markets, or of one with `asset`, as the protocol's last configuration events set it — loan-to-value, liquidation threshold, reserve factor and liquidation protocol fee in basis points, the liquidation bonus in basis points over the debt repaid (500 = 5 %), supply and borrow caps in whole tokens (absent means no cap), whether the asset is active, frozen or paused, its price oracle, its receipt and debt token contracts and rate strategy, and the block of its last configuration change. `protocol` must be a covered one (`aave_v3` today; another is refused, `protocol_invalid`, with the covered list), and `coveredMarkets` names the markets read. A value is absent when the asset's initialization lies outside the history TraceFast reads. Use it to read a lending market's parameters. Not for one token's amounts and rates: use get_token_lending_markets. Arguments: protocol; optional asset. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/lending-config

NameTypeReqDescription
assetstring–Only this asset (`0x` + 40 hex).
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
protocolstringyesA covered protocol, for example `aave_v3`; another value is refused (`protocol_invalid`) with the covered list.

Structured output declared, but exposes no named fields.

No examples provided.

get_network_daily ~427

Per UTC day over a window of dates, oldest first, the network's totals: blocks (count, first and last), transactions (all, successful, failed, contract creations) and the ETH they moved, gas used and the average block's utilization, the average block time, withdrawals, the base fee (average, median, 10th and 90th percentile, wei), the fees burnt and the blob gas used. Before the Byzantium fork (2017-10-16) receipts carry no status, so the successful and failed counts read 0 there and are not counts. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart the chain's activity and fees over time. Not for one block (get_block) or the gas prices paid and transaction types (get_gas_daily). Not for the new accounts and contracts of each day: use get_new_accounts_daily. Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-daily

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
fromstring–The first UTC date, `YYYY-MM-DD`.
tostring–The last UTC date, `YYYY-MM-DD`. Default: today.

Structured output declared, but exposes no named fields.

No examples provided.

get_new_accounts_daily ~323

Per UTC day over a window of dates, oldest first: how many externally owned accounts (`newEoas`) and how many contracts (`newContracts`) appeared on the chain for the first time. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; a day with no figures is absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart how fast the chain gains accounts and contracts. Not for when one address first appeared: use get_entity_activity. Arguments: none required; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/network-new-accounts

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
fromstring–The first UTC date, `YYYY-MM-DD`.
tostring–The last UTC date, `YYYY-MM-DD`. Default: today.

Structured output declared, but exposes no named fields.

No examples provided.

get_new_pools ~456

DEX pools in the order of their first swap, newest first — the pool (its address, or `poolId` for a Uniswap v4 pool), its protocol and version, and its first swap's block, time, transaction, tokens and amounts in token units. A pool appears once it has swapped: one created but never traded is not listed. The list is updated hourly and complete through `meta.asOfBlock`; a few protocols lag the others by some hours. No USD value is stated: a new pool's price is the least reliable one. Use it to find pools that just started trading. Not for every pool of one token, by creation: use get_token_pools. For one pool in full, use get_pool. Not for a new pool's later swaps: use get_pool_swaps. Arguments: none required; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/pools-new

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_pool ~451

One DEX pool by its address or, for a pool without one, its 32-byte id (a Uniswap v4 PoolId) — its protocol and version, its tokens with the symbol, name and decimals each token contract declares (verbatim, not verified), the fee tier and tick spacing where recorded, the factory, hook, vault, gauge and LP token where it has them, its creation block and transaction, and its USD volume and swaps over UTC days (`volumeUsd2d` / `swaps2d`: yesterday and today; `volumeUsd8d` / `swaps8d`: today and the 7 days before). A volume over days not all priced is a partial sum, with the unpriced days counted beside it. A pool that trades but is not registered with TraceFast answers what its swaps show (`registered: false`); an unknown one is refused (`not_found`). No names or verdicts. Use it to identify a pool. Not for its trades (get_pool_swaps) or what it holds now (get_pool_reserves). Not for its volume day by day: use get_pool_volume. Not for the liquidity added and removed day by day: use get_pool_liquidity_flow. Arguments: pool. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
poolstringyesThe pool's address (`0x` + 40 hex), or a Uniswap v4 PoolId (`0x` + 64 hex); any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_pool_liquidity_events ~642

The liquidity events of one DEX pool inside a block window, newest first — the block, time and transaction, the provider the event names, `action` (`add` or `remove`) and the event as the pool names it, and the USD added or removed over the token legs that could be priced (`pricedLegs` / `unpricedLegs`; absent when none could). The window is `fromBlock` to `toBlock`, at most 216 000 blocks (about 30 days), by default the 7 days up to `meta.asOfBlock`; a wider one is refused with the bound, never narrowed, and a `toBlock` past `meta.asOfBlock` is refused (`block_not_available`). Uniswap v4 pools are not covered and are refused (`pool_not_covered`) rather than answered empty. Use it to see who added or removed liquidity in a pool. Not for daily totals: use get_pool_liquidity_flow. Not for every token leg of one transaction's events: use get_transaction_liquidity_events. Not for the largest removals across all pools: use get_largest_liquidity_removals. Arguments: pool; optional fromBlock, toBlock, limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pool-liquidity-events

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
fromBlockinteger–The window's first block. Default: 7 days of blocks below `toBlock`.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
poolstringyesThe pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.
toBlockinteger–The window's last block. Default: the last block the liquidity events have reached (`meta.asOfBlock`).

Structured output declared, but exposes no named fields.

No examples provided.

get_pool_liquidity_flow ~403

Per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first: the USD value of the liquidity added to and removed from a DEX pool and the net flow, the add and remove events and the distinct providers behind them, and how many of the events' token legs could be priced (`pricedLegs` of `totalLegs`: below it the USD figures cover the priced legs only). A day without liquidity events has no entry. Uniswap v4 pools are not covered and are refused (`pool_not_covered`) rather than answered empty. Use it to see whether liquidity is entering or leaving a pool over time. Not for the individual events: use get_pool_liquidity_events. Not for what the pool holds now: use get_pool_reserves. Arguments: pool; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-liquidity-flow

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
daysinteger–1 to 365, default 30.
poolstringyesThe pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_pool_reserves ~386

What a DEX pool holds now, token by token — the raw reserve, the amount in token units where the decimals are known, and its USD value where the token has a price TraceFast trusts at that size — and `totalTvlUsd`, the USD total over the legs that could be valued (absent when none could). The total is an estimate, not an accounting value, and says how far it can be relied on: `isTvlTrusted`, `reserveStatus`, `accuracyBand` and `accuracyDeltaBps` (the gap to a direct read of the pool), with the snapshot's block and age (`snapshotBlock`, `snapshotLagSeconds`). A pool whose reserves TraceFast does not track is refused (`not_found`). Use it to see how deep a pool is. Not for its trading over time: use get_pool_volume. Not for the liquidity added and removed over time: use get_pool_liquidity_flow. Arguments: pool. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the latest snapshot, which names its own block and age; the answer as a whole states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-reserves

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
poolstringyesThe pool's address (`0x` + 40 hex), or a Uniswap v4 PoolId (`0x` + 64 hex); any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_pool_swaps ~535

Every swap of one DEX pool, newest first — the block, time and transaction, the sender and recipient as the pool's event states them (the sender is often a router), the token sold in and the token bought out with raw amounts, decimals and the symbols the tokens declare (verbatim, not verified), and `valueUsd`, an estimate at the hour of the swap: the bought leg at that hour's price, else the sold one (`valuedLeg`); a leg larger than its price can vouch for is left unvalued, never capped. `pool` is the pool's address or its 32-byte id (a Uniswap v4 PoolId or a Balancer v2 poolId). Use it to read a pool's trades. Not for daily totals (get_pool_volume) or one address's trades across pools (get_entity_dex_trades). Arguments: pool; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/pool-swaps

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
poolstringyesThe pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_pool_volume ~406

A DEX pool's trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — USD volume, swaps, the volume of each of its two tokens in token units and how many distinct addresses sent swaps — with the totals. A day's USD volume adds the hours that could be priced: a day with swaps but no priced hour has no `volumeUsd` and is counted in `unpricedDays` (then `totalVolumeUsd` is a partial sum); a day priced only in part is not marked. A day without swaps has no entry. A pool not registered with TraceFast is refused (`not_found`). Use it to chart a pool's trading. Not for the swaps themselves: use get_pool_swaps. Not for the liquidity added and removed: use get_pool_liquidity_flow. Arguments: pool; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/pool-volume

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
daysinteger–1 to 365, default 30.
poolstringyesThe pool's address (`0x` + 40 hex), or its own 32-byte id (`0x` + 64 hex: a Uniswap v4 PoolId, or a Balancer v2 poolId); any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_pools_for_pair ~521

Every DEX pool that holds both `tokenA` and `tokenB` — in either order, including pools of three or more tokens that hold both — newest created first, each with its protocol and version, fee tier where recorded (absent does not mean no fee), approximate creation block (`creationBlockApprox`), its tokens and its USD volume over the last 7 days (`volumeUsd7d`; absent when none could be priced, not zero). Uniswap v4 pools are included and named by their `poolId`. At most the 200 newest pools (`truncated` says when more exist), paged by bytes: about 224 KiB a page, a whole pool at a time; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`. A pool lists at most 8 of its tokens (`tokenCount` when it holds more). Use it to find where two tokens trade against each other. Not for every pool of one token: use get_token_pools. For one pool in full, use get_pool. Arguments: tokenA, tokenB; optional cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/pools-by-pair

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
tokenAstringyesOne token contract, `0x` + 40 hex. Required.
tokenBstringyesThe other token contract, `0x` + 40 hex. Required.

Structured output declared, but exposes no named fields.

No examples provided.

get_signal_kinds ~301

The vocabulary of TraceFast's detector signals: every kind get_signals serves as a row (`rowKinds`), each with the detector that raises it, whether it is always in the trader view (`alwaysTrader`) and the evidence fields it carries (`a.b` means only the field `b` of the object `a`); the kinds get_signal_rates counts instead of listing (`countedKinds`); and the detectors whose coverage get_signal_rates states. A kind names what a detector looks for — a hypothesis about what happened, never a finding about an address. Use it to learn the values `kind` takes and how to read a signal's `evidence`. Not for the signals themselves: use get_signals. Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the vocabulary TraceFast serves now; it changes only when its detectors do, and states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/signal-kinds

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_signal_rates ~405

Over the same 7 200 blocks as get_signals (about 24 hours, ending at `meta.asOfBlock`): how many signals were raised of each kind get_signals does not list (`counts`; the `countedKinds` of get_signal_kinds always appear, zero included), flash-loan transactions by class (`flashLoans`), how far each detector has covered the window (`coverage`), and the ten delegated (EIP-7702) account outflows with the largest net ETH out, gas included, with the tokens that left (raw amounts; `decimals` absent when unknown — then print the amount raw): at most 5 tokens an outflow (`tokensTruncated` when more left) and 5 NFT ids a token (`tokenIdCount` when more left). An absent coverage field is unknown, and a count beside unknown or partial coverage is not "nothing happened". Recomputed at most once a minute. A signal is a detector's hypothesis, not a fact about an address. Use it for the window's counts and to check a detector's coverage before reading an empty get_signals page as quiet. Not for the signals themselves: use get_signals. Not for the flash loans of one transaction: use get_transaction_flash_loans. Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/signal-rates

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_signals ~648

The signals TraceFast's detectors raised over the last 7 200 blocks (about 24 hours, ending at `meta.asOfBlock`), newest block first. A signal is a detector's fast hypothesis about what it saw on chain, never a fact about an address: read its `evidence`. Each row names its `kind`, `detector` and `subject` (the contract or account it is about), its block, its transaction where it is about one, its position where stated (`logIndexInTx`, `callPath`, `slot`), whether the detector read every input (`complete`) and the evidence fields of its kind; `horizonTruncated` says the window's oldest signals are missing. `kind` (comma-separated), `address` (the subject or any address in the evidence) and `trader` (the trader view) select the set before the page. A detector that has not covered a block cannot raise a signal in it: check get_signal_rates before reading an empty page as quiet. Use it to see what the detectors raised recently. Not for the kinds and their evidence fields: use get_signal_kinds. Not for issuers listing or freezing addresses: use get_blacklist_feed. Arguments: none required; optional kind, address, trader, limit (default 25, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/signals

NameTypeReqDescription
addressstring–Only signals naming this address (`0x` + 40 hex) as their subject or anywhere in their evidence.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
kindstring–Row kinds, comma-separated (for example `lp_drained,lookalike_paid`); each must be a row kind of getSignalKinds, or the request is refused (`kind_invalid`) with the list.
limitinteger–How many rows to return: 1 to 100, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
traderboolean–`true`: only the trader view; `false`: only the others; absent: both.

Structured output declared, but exposes no named fields.

No examples provided.

get_token ~349

One token contract: its standard as observed from its events (erc20, erc721, erc1155), the symbol, name and decimals it declares (verbatim, not verified), its all-time transfer count, how many addresses hold it now (`holderCount`, the same number get_token_holders states; absent where holders are not covered, such as NFT collections) and how many ever held it (`holderCountAllTime`). A contract with no transfer events is refused (`not_found`). No price here. Use it to identify a token contract and read its decimals. Not for its holders (use get_token_holders) or the contract as an address (get_entity_overview). Not for its transfers: use get_token_transfers. For its USD price, use get_token_price. Not for the DEX pools that hold it: use get_token_pools. Arguments: token. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: current all-time counters, refreshed periodically; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
tokenstringyesThe token contract address, `0x`-prefixed, 40 hex characters, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_dex_volume ~415

A token's DEX trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — the USD volume and the swaps by the token's position in the pair (`swapsAsToken0` / `swapsAsToken1`: the pair position, not a buy or sell direction) — with the totals. A day's USD volume adds the hours that could be priced: a day with swaps but no priced hour has no `volumeUsd` and is counted in `unpricedDays` (then `totalVolumeUsd` is a partial sum); a day priced only in part is not marked. A day without swaps has no entry. Only the pools TraceFast decodes are counted, which may lag a newly created pool. Use it to chart how much a token trades. Not for where it trades: use get_token_pools. Not for the whole chain's DEX volume: use get_dex_volume_daily. Not for the tokens that trade most: use get_top_dex_tokens. Arguments: token; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-dex-volume

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
daysinteger–1 to 365, default 30.
tokenstringyesThe token contract, `0x` + 40 hex, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_holders ~524

The largest current holders of a token, in descending balance order, with the balance in the token's smallest unit, plus `holderCount` — how many addresses hold a positive balance now — the same balances get_entity_token_balance answers, and `asOfBlock`, the block the ranking is valid at (absent when the ranking was being recomputed while it was read). Current ranking only. Pass `nextCursor` back as `cursor` to go past the first page: the ranking holds `rankingDepth` holders (up to 1 000) and `rankingTruncated` says whether more rank below; a cursor from before the ranking was recomputed (about hourly, at the earliest after 5 minutes) is refused (`invalid_cursor`: start again). A token whose holders are not covered (every NFT collection today) is refused (`token_not_covered`) rather than answered with zero holders. Use it to find who holds a token. Not for one holder's exact balance: use get_entity_token_balance. Arguments: token; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-holders

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
tokenstringyesThe token contract address, `0x`-prefixed, 40 hex characters, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_lending_markets ~410

The lending markets where a token is listed, one per market — its roles there (`supply`, `borrow`, `collateral`), the amounts supplied and borrowed (raw units, and USD at the protocol's own oracle price), the supply and borrow rates as yearly fractions, loan-to-value and liquidation threshold in basis points, the liquidation bonus in basis points over the debt repaid (500 = 5 %), the caps (absent means no cap) and how much of each is used — above 100 % when a cap was lowered below what is already supplied — and whether the market is active, frozen or paused. `coveredMarkets` names the markets TraceFast reads (Aave V3's main Ethereum market today): an empty `markets` means not listed on those, never not lendable anywhere. The amounts use the market's interest index of its last rate update, so on a quiet market the interest accrued since is not in them. Use it to see where, and on what terms, a token can be supplied or borrowed. Not for a protocol's whole configuration: use get_lending_market_config. Not for the token's market price over time: use get_token_price_history. Arguments: token. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the current state; `meta.asOfBlock` is the block the answer is valid at. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-lending-markets

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
tokenstringyesThe token contract, `0x` + 40 hex.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_pools ~550

The DEX pools that hold a token, newest created first — each with its protocol and version, fee tier where recorded (absent does not mean no fee), approximate creation block, its tokens (address, declared symbol and decimals, role, weight where the pool declares one) and its USD volume over the last 7 days (`volumeUsd7d`; absent when none could be priced, not zero). A Uniswap v4 pool has no address and is named by its `poolId`. At most the 10 000 most recently created pools of a token are ranked; `rankedPools` says how many. A page of pools whose tokens declare long texts can hold fewer than `limit` (pages are bounded in bytes); `nextCursor` then continues it. A pool lists at most 8 of its tokens (`tokenCount` when it holds more). Use it to find where a token trades. Not for the pools of two given tokens: use get_pools_for_pair. Not for the pools that just started trading: use get_new_pools. Arguments: token; optional limit (default 10, at most 100), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the pools as TraceFast's pool list holds them, refreshed in batches behind the chain — a pool created since may be missing. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/token-pools

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
tokenstringyesThe token contract, `0x` + 40 hex, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_price ~454

The USD price of a token for one hour — the newest priced hour by default, or the newest at or before `timestamp` (Unix seconds) or the time of `block` (one or the other): `priceUsd`, the hour it is for (`hour`), what it is (`priceSource`: an oracle reading, a DEX observation, a peg, or one carried over from an earlier hour, with `observedHour` and `ageHours`), and `maxTrustedValueUsd`, the largest USD value it may vouch for (absent means no bound): an amount worth more at this price is not valued by it. The DEX and oracle sides it was chosen from are separate blocks (`dex`, `oracle`), with how far they disagree (`divergencePct`: a number, not a verdict). TraceFast prices a selected set of tokens; any other is refused (`not_found`). Use it to value a token amount. Not for prices over time (get_token_price_history) or an address's holdings in USD (get_entity_portfolio). Arguments: token; optional timestamp, block. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: hourly USD prices; the newest hour is usually the current or the previous one, and each price names its hour. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-price

NameTypeReqDescription
blockinteger–A block: the price as of the hour holding its time. Not with `timestamp`.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
timestampinteger–Unix time, seconds: the price as of the hour holding it. Not with `block`.
tokenstringyesThe token contract, `0x` + 40 hex, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_price_history ~426

A token's USD price for every priced hour of a window (`from` to `to`, Unix seconds; the last 7 days by default, at most 90 days), oldest first — each with `priceUsd`, what it is (`priceSource`), whether it was carried over from an earlier hour (`carried`), `maxTrustedValueUsd` (absent means no bound) and the hour's DEX and oracle prices where they exist. An hour without a price has no entry, not a zero. A window over 90 days is refused with the bound, never narrowed. TraceFast prices a selected set of tokens: any other answers an empty list here, while get_token_price refuses it. Use it to chart a token's price. Not for one hour's price with its sources in detail: use get_token_price. Not for how much it trades: use get_token_dex_volume. Arguments: token; optional from, to. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: hourly USD prices; the newest hour is usually the current or the previous one, and each price names its hour. It states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/token-price-history

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
frominteger–Unix time, seconds: the window's start (its hour included). Default: 7 days before `to`.
tointeger–Unix time, seconds: the window's end (its hour included). Default: now.
tokenstringyesThe token contract, `0x` + 40 hex, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_stats ~226

How many token contracts, transfer events and holder positions (one address holding one token; not distinct addresses) the chain counts, in total and per standard (ERC-20, ERC-721, ERC-1155, ERC-777, ERC-4626). Use it for the size of the chain's token landscape. Not for one token: use get_token. Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: network-wide all-time counters, recomputed daily; they state no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/token-stats

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.

Structured output declared, but exposes no named fields.

No examples provided.

get_token_transfers ~766

The transfer events of one token contract, newest first — the parties, the raw amount (not scaled by decimals) or token id, the event kind, and the transaction that emitted it with who sent that transaction, which on a router or a batch disburser is another party entirely. ERC-20, ERC-721 and ERC-1155 transfers, and the token's other value events: `eventType` is one of `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap` or `unwrap`. `deposit` and `withdraw` are vault (ERC-4626) events; wrapping and unwrapping ether (WETH) are `wrap` (no sender) and `unwrap` (no recipient). `from`, `to`, `eventType` and `fromBlock` / `toBlock` narrow the list; on a very active token `from`, `to` or `eventType` is answered only inside a block window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to follow a token's movements. Not for one address's transfers across tokens (get_entity_token_transfers) or who holds it now (get_token_holders). Arguments: token; optional limit (default 10, at most 100), cursor, from, to, eventType, fromBlock, toBlock. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: the history as TraceFast holds it now, newest first; each row names its block, and the page states none (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Enriched Data; the Intelligence and Investigation plans include it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/token-transfers

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
eventTypestring–One event kind: `transfer`, `transfer_single`, `transfer_batch`, `sent`, `minted`, `burned`, `deposit`, `withdraw`, `wrap`, `unwrap`. `deposit` and `withdraw` are vault (ERC-4626) events; wrapping an…
fromstring–Only transfers sent by this address, `0x`-prefixed.
fromBlockinteger–Inclusive lower block bound.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.
tostring–Only transfers received by this address, `0x`-prefixed.
toBlockinteger–Inclusive upper block bound.
tokenstringyesThe token contract address, `0x`-prefixed, 40 hex characters, any case.

Structured output declared, but exposes no named fields.

No examples provided.

get_top_dex_tokens ~498

The tokens with the most USD volume on the DEXes TraceFast decodes over the last `days` UTC days (1 to 30, default 7; today included and still being counted), most volume first — each with the symbol its contract declares (verbatim, not verified: identify a token by its address), its USD volume, its swaps by its position in the pair (`swapsAsToken0`, `swapsAsToken1`: the pair position, not a buy or sell side) and the most pools it traded in on one day. A volume adds only what could be priced: `unpricedDays` counts the days with no price at all (the volume is then partial), and a day priced in part counts as priced, so the ranking may order partial sums. Native ETH appears as the venues record it, `0x0000…0000` and `0xeeee…eeee`. The top 100 only: the maximum `limit` is the deepest it goes. Use it to find the most traded tokens. Not for pools: use get_top_pools. Not for DEX volume day by day and protocol by protocol: use get_dex_volume_daily. Arguments: none required; optional days, limit (default 10, at most 100). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/network-top-dex-tokens

NameTypeReqDescription
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
daysinteger–1 to 30, default 7.
limitinteger–How many rows to return: 1 to 100, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

get_top_pools ~665

DEX pools ranked by USD volume over the last `days` UTC days (`by` `volume`, the default; `days` 1 to 30, default 7, today included and still being counted) or by the USD value they hold now (`by` `tvl`: only pools whose total TraceFast rates as trustworthy rank, each with that rating's `accuracyBand`; `days` with it is refused, `conflicting_parameters`). Each with the pool — its address, or for a Uniswap v4 pool its 32-byte `poolId` — the protocol and version, and its tokens with their declared symbols (verbatim, not verified). A volume adds only what could be priced: `unpricedDays` counts the days with no price at all, and a day priced in part counts as priced, so the ranking may order partial sums. The ranking is the top 100, at most 20 a page: `hasMore` says it goes on — pass `nextCursor` back as `cursor`; a cursor from a ranking recomputed since is refused (`invalid_cursor`: restart). A pool lists at most 8 tokens: `tokenCount` says how many it holds when that is more (with `by` `volume` the tokens are the pair its swaps traded), `tokenCountState` `unknown` that the count could not be read. Use it to find the busiest or deepest pools. Not for tokens: use get_top_dex_tokens. Arguments: none required; optional by, days, limit (default 5, at most 20), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: a daily aggregate; the window ends at the latest day it holds, and the answer states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/network-top-pools

NameTypeReqDescription
bystring–`volume` (default) or `tvl`.
chain_idinteger–Chain id. Only 1 (Ethereum mainnet) is served; the default.
cursorstring–`data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call.
daysinteger–1 to 30, default 7: the volume window. Refused when `by` is `tvl` (`conflicting_parameters`).
limitinteger–How many rows to return: 1 to 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut.

Structured output declared, but exposes no named fields.

No examples provided.

Install

How do I install the TraceFast MCP server?

TraceFast is a hosted endpoint at https://tracefast.xyz/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

remote · tracefast.xyz

# add to Claude Code
claude mcp add --transport http xyz-tracefast-mcp 'https://tracefast.xyz/mcp'
Common questions

What is the TraceFast MCP server?

TraceFast is an MCP server listed in the public MCP registry as xyz.tracefast/mcp. Ethereum data for agents: blocks, transactions, traces, tokens, and facts about addresses. This page covers its hosted endpoint (https://tracefast.xyz/mcp).

Is the TraceFast MCP server safe to use?

TraceFast scores 74 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

What tools does the TraceFast MCP server expose?

TraceFast exposes 110 tools: get_blacklist_events, get_blacklist_feed, get_blacklist_issuers, get_blacklist_status, get_blacklisted_addresses, and 105 more. Their descriptions and schemas cost roughly 52,848 tokens of context every time the server is loaded.

Does the TraceFast MCP server require authentication?

No. We connected to TraceFast without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

Is the TraceFast MCP server still maintained?

TraceFast is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

What did VerifyMCP test on the TraceFast MCP server?

VerifyMCP ran 13 checks on TraceFast, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.