TraceFast
REMOTE · TRACEFAST.XYZ
Ethereum data for agents: blocks, transactions, traces, tokens, and facts about addresses.
Available components
Last scanned (17 hours ago)
Scores higher than 60% of remote servers
Reachable. Last reached 21 Nov 2026.
Category Crypto and Web3
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
- Verified streamable-http transport via a live MCP handshake. View diagnostics → Pass
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
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 →
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.
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 |
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 →
get_blacklist_events Blacklist events about one address ~501
Every blacklist event an issuer contract recorded about an address, newest first — listed (`add`), removed (`remove`) or enforced against (`enforce`: funds destroyed or frozen) — each with the issuer and its weight (`authorityTier`), the event's name as the issuer's contract declares it, and the transaction that emitted it. Facts the issuers' own contracts recorded on chain; no external sanctions lists. `issuerContract` or `action` narrows the list. Use it to see when, and by whom, an address was listed or frozen. Not for one row per issuer with its current standing: use get_blacklist_status. Not for every blacklist event on the chain: use get_blacklist_feed. Arguments: address; optional limit (default 10, at most 100), cursor, issuerContract, action. `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/risk-blacklist-events
| Name | Type | Req | Description |
|---|---|---|---|
| action | string | – | Only events of this kind: `add`, `remove` or `enforce`. |
| address | string | yes | The address, `0x`-prefixed, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| issuerContract | string | – | Only events emitted by this issuer contract, `0x`-prefixed. |
| limit | integer | – | 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_blacklist_feed Every blacklist event on the chain, newest first ~532
Every blacklist event any issuer contract recorded on the chain, newest first — an address listed (`add`), removed (`remove`) or enforced against (`enforce`: funds destroyed or frozen) — each with the address, the issuer contract and its weight (`authorityTier`), the event's name as the issuer's contract declares it, and the block and transaction that emitted it. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. `issuerContract` or `action` narrows the feed. Use it to follow what issuers listed or froze recently: page until the events reach the block you last read. Not for one address's events: use get_blacklist_events. Not for the addresses listed now: use get_blacklisted_addresses. Not for the issuers and how many addresses each lists: use get_blacklist_issuers. Arguments: none required; optional limit (default 10, at most 100), cursor, issuerContract, action. `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/risk-blacklist-feed
| Name | Type | Req | Description |
|---|---|---|---|
| action | string | – | Only events of this kind: `add`, `remove` or `enforce`. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| issuerContract | string | – | Only events emitted by this issuer contract, `0x`-prefixed. |
| limit | integer | – | 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_blacklist_issuers The issuer contracts that keep blacklists ~481
The contracts that keep on-chain blacklists — every contract that ever recorded a blacklist event, with its weight (`authorityTier`), its token symbol where it is a token (as the contract declares it, not verified), and how many addresses it lists now (`currentlyListed`), has ever listed (`everListed`) and has enforced against (`enforced`) — most addresses listed now first; plus totals over every issuer: `issuerCount`, `listedPairs` (an address listed by two issuers counts twice) and `listedAddresses`. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. The counts trail the newest events by a few minutes. The top of the ranking only: the maximum `limit` is the deepest it goes, and a list of issuers with long declared symbols can end before it (bounded in bytes; `issuersTruncated` says so). Use it to see which issuers keep blacklists and how large each is. Not for the listed addresses (get_blacklisted_addresses) or one address's standing (get_blacklist_status). Not for the issuers' latest events: use get_blacklist_feed. Arguments: none required; optional limit (default 25, at most 1000). `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: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-issuers
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| limit | integer | – | How many rows to return: 1 to 1000, 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_blacklist_status Which issuer contracts list one address ~314
Every issuer contract that ever placed an address on its on-chain blacklist — one row each, listed now or not, with the issuer's weight (`authorityTier`), its first and latest events and how many times it listed and removed the address — plus, as a separate fact, the issuers that enforced against it (funds destroyed or frozen). Facts the issuers' own contracts recorded on chain; no external sanctions lists, and no single verdict: a listing is one issuer's decision. Empty lists mean no issuer recorded anything about the address. Use it to check whether token issuers such as stablecoins have listed or frozen an address. Not for the individual events: use get_blacklist_events. Not for every address listed now: use get_blacklisted_addresses. 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: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/risk-blacklist-status
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_blacklisted_addresses The addresses issuer contracts list now ~506
Every (address, issuer contract) pair where the issuer's on-chain blacklist holds the address now, in address order — with the issuer's weight (`authorityTier`), the block it first listed the address, its latest event about the address of any kind (`lastEventKind`; not the start of the current listing) and how many times it enforced against it. An address listed by two issuers appears twice. Facts the issuers' own contracts recorded on chain; no external sanctions lists, and a listing is one issuer's decision, not a verdict about the address. `issuerContract` narrows the list to one issuer. The listings trail the newest events by a few minutes, which get_blacklist_feed shows first. Use it to enumerate the addresses listed now. Not for whether one address is listed: use get_blacklist_status. Not for how many addresses each issuer lists: use get_blacklist_issuers. Arguments: none required; optional limit (default 10, at most 100), cursor, issuerContract. `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: standard. Documentation: https://docs.tracefast.xyz/api/risk-blacklisted
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| issuerContract | string | – | Only the addresses this issuer contract lists, `0x`-prefixed. |
| limit | integer | – | 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_blobs_daily Blobs per day ~346
Per UTC day over a window of dates, oldest first: the EIP-4844 blobs posted (`blobs`), the transactions that carried them (`blobTransactions`) and how many distinct addresses sent those transactions (`uniqueSenders`). `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 days, by default the last 30; days before blobs existed and any day with no figures are absent, and a day still being counted — today, and at times yesterday — is marked `provisional`. Use it to chart blob usage over time. Not for gas prices and transaction types (get_gas_daily) or the network's blocks, fees and blob gas (get_network_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-blobs
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| from | string | – | The first UTC date, `YYYY-MM-DD`. |
| to | string | – | The last UTC date, `YYYY-MM-DD`. Default: today. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block One block ~288
One block by height: its header (hash, parent, roots, fee recipient, gas, base fee, blob gas) and the totals of what it contains — transactions by outcome, contract creations, blob transactions, logs, withdrawals, value moved, fees burnt and paid. A height not served yet is refused (`not_found`). Use it to inspect a known height. Not for the newest block: use get_latest_block. Not for its transactions one by one: use get_block_transactions. Not for the withdrawals it paid one by one: use get_block_withdrawals. Not for the accounts whose state it changed: use get_block_addresses. Arguments: number. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| number | integer | yes | Block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_addresses Accounts touched by one block ~470
Every account whose own state — native balance, nonce or code — changed in one block, in address order, each with what changed, whether it was created in this block, and its native balance before and after the block — plus `addressCount`, the block's whole count. An account only mentioned by the block's activity, with no state change, is not listed; a block with no account change answers an empty list, which is a fact about that block. A height above the chain head is refused (`not_found`). Use it to find whose state a block changed. Not for the block's transactions (get_block_transactions) or one address's activity over time (get_entity_daily_activity). Not for every address the block touched, its state changed or not, with its roles: use get_block_participants. Arguments: number; 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: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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/block-addresses
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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. |
| number | integer | yes | Block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_at_time Which block was the chain's at a given time ~353
Which block the chain was at at a moment: for `timestamp` (Unix seconds), the last block whose time is at or before it (`block`, its number and time) and the first block after it (`nextBlock`). Block times rise strictly with the height, so the bracket is exact. `final` is false when the time is after the newest block served: a later block may still land at or before it, `nextBlock` is absent, and the same question may answer differently later. When blocks around the time are temporarily unavailable the call is refused (`block_not_available`, `details.reason` `coverage_gap`) rather than bracketed across the gap — retry later. Use it to turn a date or time into a block height for the tools that take a block. Not for the block's contents: pass `block.number` to get_block. Not for the newest block now: use get_latest_block. Arguments: timestamp. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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-at-time
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| timestamp | integer | yes | Unix time, seconds. Required. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_authorizations EIP-7702 authorizations of one block ~504
The EIP-7702 authorizations carried by the transactions of one block, in transaction order and then list order — each with the contract the signing account delegates its code to, the signing account itself (`authority`, with `authorityStatus`: `recovered`, `recovery_failed` for an invalid signature, `not_available` while not determined), the chain id and nonce it was signed for, the signature, and the carrying transaction's hash and position. Empty when the block carries no type-4 transaction. A height above the chain head is refused (`not_found`). Use it to see which delegations a block carried. Not for where an account delegates now: use get_entity_relations; not for the block's transactions: use get_block_transactions. Arguments: number; 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: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `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/block-authorizations
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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. |
| number | integer | yes | Block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_internal_transfers Every internal ETH transfer of a block ~595
Every call frame of one block that moved ETH below a transaction's own top-level call — sends from contracts, value carried by inner calls, self-destruct payouts, contract creations with value — in transaction order, each with the transaction and who sent it (`txSender`), the frame's depth (`callDepth`, 2 = called by the transaction's target), its kind (`callType`), from, to, the amount in wei and the frame's own outcome (`status`). A frame that succeeded inside a reverted transaction, or under a reverted parent, moved nothing in the end. `total` counts the whole block. A height not served yet is refused (`not_found`); a block the traces do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later — never answered with an empty list, so an empty list is a fact about the block. Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy block at the maximum. Use it to see all the ETH a block moved through contracts. Not for one address's internal transfers across blocks (get_entity_internal_transfers) or one transaction's whole call tree (get_transaction_trace). Arguments: number; optional limit (default 25, at most 200), 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: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `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:…
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| number | integer | yes | The block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_participants Every address a block touched, and how ~613
Every address that took part in one block, in the block's order — system calls before the first transaction, then by first transaction, then the rest (withdrawals, the fee recipient) — each with its `roles` (transaction sender or recipient, caller or callee, token party, created, named in an event and more), the one class it is counted under (`primaryClass`), how many of the block's transactions it took part in, whether its own account changed with the balance before and after and the signed ETH delta (`stateChange`), its token transfers in the block summed per token in raw units (`tokenFlows`: transfers, not balance changes), and what TraceFast states the address was at that block (`nature`, only when `natureState` is `known`; `not_computed` says nothing about the address). The block's counts come with every page. No names or labels. A block whose participants are not computed yet is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later — never answered empty. Keep the same `limit` for every page of one walk: a cursor does not continue under another. Use it to see whom a block touched and how. Not for only the accounts whose state changed (get_block_addresses) or the block's transactions (get_block_transactions). Arguments: number; optional 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: facts of a mined block, written in batches that trail the newest blocks; a block they do not reach yet is refused (`block_not_available`, with `details.maxAvailableBlock`, the highest block answered) — retry later, it says nothing about the block. `meta.asOfBlock` is the block the answer is about. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes);…
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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. |
| number | integer | yes | The block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_proposers Block-proposal leaderboard ~475
Which validators proposed the most blocks over a window (`period`: `7d` by default, `30d`, `90d`, `1y` or `all`), or — with `groupBy` set to `address` — which withdrawal addresses their proposals add up to, with the window's total blocks and distinct proposers. The proposer is the validator whose duty the slot was, never the block's fee recipient (usually a builder); a withdrawal address is where payouts go, not an operator. The two groupings rank different sets. The top of the ranking only: the maximum `limit` is the deepest it goes. Use it to see who proposes the chain's blocks. Not for one validator's payouts: use get_validator_withdrawals. Not for one validator's proposals and misses slot by slot: use get_consensus_validator_slots. Arguments: none required; optional period, groupBy, 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 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: heavy. Documentation: https://docs.tracefast.xyz/api/consensus-proposers
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| groupBy | string | – | `validator` (default) or `address`. |
| limit | integer | – | 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. |
| period | string | – | `7d` (default), `30d`, `90d`, `1y` or `all`. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_token_transfers Every token transfer of a block ~537
Every token transfer event of one block, in transaction and log order — ERC-20, ERC-721 and ERC-1155 transfers, mints, burns, vault deposits and withdrawals, WETH wraps and unwraps — each with the token contract and its standard (`tokenStandard`), the event kind (`eventType`), from, to, the raw amount (not scaled by decimals) or token id, and the transaction with its sender and target. No symbols: identify a token by its address and read its decimals with get_token. `total` counts the whole block; a block with no token transfers answers an empty list, which is a fact about that block. A height not served yet is refused (`not_found`), and a block temporarily unavailable is refused (`block_not_available`, `details.reason` `coverage_gap`) — retry later. Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy block at the maximum. Use it to see every token movement of a block. Not for one token's transfers across blocks (get_token_transfers) or one address's (get_entity_token_transfers). Arguments: number; optional limit (default 25, at most 200), 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: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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/block-token-transfers
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | How many rows to return: 1 to 200, default 25. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| number | integer | yes | The block height. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_transactions Transactions of one block ~840
The transactions of one block in their order within it — each with sender, recipient, value, nonce, type, gas limit and gas used, the fee fields of its type and the price paid per gas, the called function's selector (`methodId`) and the receipt's outcome — plus `txCount`, the block's whole count. `status`, `methodId` (a selector), `minValueWei` / `maxValueWei` and `txType` narrow it, with `matchCount` the narrowed count; `sort` `value` lists the largest value first. A height not served yet is refused (`not_found`). A page of transactions with long revert texts can hold fewer than `limit` (pages are bounded in bytes too); `nextCursor` then continues it. Every call is one request against your rate limit and quota whatever its `limit`, so walk a whole block at the maximum. Use it to list what a block contains. Not for the block's header and totals (get_block) or what one transaction emitted or executed (get_transaction_events, get_transaction_trace). Not for the token transfers its transactions emitted: use get_block_token_transfers. Not for the ETH moved by inner calls: use get_block_internal_transfers. Arguments: number; optional limit (default 10, at most 100), cursor, status, methodId, minValueWei, maxValueWei, txType, sort. `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: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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/block-transactions
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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. |
| maxValueWei | string | – | Only transactions moving at most this value, in wei: a non-negative integer of at most 38 digits, not below `minValueWei`. |
| methodId | string | – | Only calls of this function: its selector, `0x` + 8 hex characters, as `methodId` carries it. A transaction whose input is shorter than four bytes has no selector and never matches. |
| minValueWei | string | – | Only transactions moving at least this value, in wei: a non-negative integer of at most 38 digits. |
| number | integer | yes | Block height. |
| sort | string | – | `index` (the default): in transaction-index order. `value`: largest `valueWei` first, equal values in transaction-index order. The direction of each is fixed. |
| status | string | – | Only transactions with this receipt outcome: `1` (success) or `0` (failure). A transaction whose receipt is not available yet matches neither. |
| txType | integer | – | Only transactions of this type: 0 legacy, 1 EIP-2930, 2 EIP-1559, 3 EIP-4844 (blobs), 4 EIP-7702; any integer up to 127 is accepted. |
Structured output declared, but exposes no named fields.
No examples provided.
get_block_withdrawals Validator withdrawals of one block ~482
The validator withdrawals paid out in one block, in withdrawal-index order — each with its global index, the validator, the address paid and the amount in gwei — plus `withdrawalCount`. A block holds at most 16, so the default page is the whole block; `validatorIndex` or `address` narrows it to one validator or one recipient. A block with no withdrawals answers an empty list, which is a fact about that block; a height above the chain head is refused (`not_found`). Use it to see who was paid in a block. Not for one validator across blocks: use get_validator_withdrawals. Arguments: number; optional limit (default 16, at most 100), cursor, validatorIndex, address. `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: facts of a mined block, served seconds after inclusion; `meta.asOfBlock` is the block the answer is about. `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/block-withdrawals
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | – | Only withdrawals paid to this address, `0x`-prefixed. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | How many rows to return: 1 to 100, default 16. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| number | integer | yes | Block height. |
| validatorIndex | integer | – | Only withdrawals of this validator index. |
Structured output declared, but exposes no named fields.
No examples provided.
get_consensus_epochs Epoch health ~487
Complete epochs of the beacon chain (32 slots each), newest first — slots proposed and missed (`missedRatio`), distinct proposers, average sync committee participation, attestations, blob commitments, deposits, voluntary exits, slashings, BLS credential changes, execution-layer requests (EIP-7685) and execution gas and transactions. The epoch in progress is absent until it is complete, and a field the epoch's fork had not introduced yet is absent, not zero. `publishedThroughEpoch` is the newest epoch published; `notHeldEpochs` counts epochs in the page's span that TraceFast does not hold right now and so does not list. Use it to follow consensus participation epoch by epoch. Not for one slot (get_consensus_slot) or whether the chain is finalizing now (get_consensus_health). 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 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/consensus-epochs
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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_consensus_health Consensus liveness ~420
The liveness of the consensus layer now: the newest head and finalized slot TraceFast saw and when (`head`, `finalized`), the distance between them (`finalizationLagSlots`), the newest published slot, missed slots over the last 24 hours (`missedSlots24h`, the newest of them listed in `missedSlots`, at most 50) and reorgs over the last 24 hours (`reorgs24h`, each one listed), plus `observation24h` — how completely the head was watched over the window — and `ages`, seconds since each moment, computed for this call. A reorg count is a statement about what was SEEN: read it next to `observation24h`, and minutes in `ages.headSeconds` mean the head is not being observed. A missed slot names its assigned validator only when `dutyStatus` is `recorded`. When the head has not been seen the call is refused (`service_unavailable`), never answered with zeros. Use it to check whether the chain is finalizing and how many slots were missed. Not for the history epoch by epoch (get_consensus_epochs) or every missed slot (get_consensus_missed_slots). Arguments: none required. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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/consensus-health
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_consensus_missed_slots Missed slots ~476
Beacon slots in which no block was proposed, newest first — each with its epoch, its time and, when `dutyStatus` is `recorded`, the validator that was assigned to it (`validatorIndex`); below slot 14 971 296 assignments were never captured and the status is `not_recorded`, permanently. Slots are published once finalized, 13–19 minutes behind the chain head (`publishedThroughSlot`). `notHeldSlots` counts slots in the page's span that TraceFast does not hold right now: a missed slot among them is not listed. Use it to list recent missed proposals and who missed them. Not for one validator's misses (get_consensus_validator_slots) or one slot in full (get_consensus_slot). 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 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: standard. Documentation: https://docs.tracefast.xyz/api/consensus-missed-slots
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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_consensus_slot One beacon slot ~449
One beacon slot: whether a block was proposed (`proposed`) and by which validator (`proposerIndex`), the validator ASSIGNED to it (`duty`: known from slot 14 971 296 on, `not_recorded` below, permanently; `duty.fulfilled` says the slot has a block and does not compare proposer and assignee), its epoch and time, and the execution block (`execution`: number, hash and fee recipient — the address paid for the block, under MEV-Boost usually the builder, not the validator). A missed slot carries no block fields. `graffitiHex` is the proposer's free 32-byte field, raw, and `graffiti` its text when it is text: words the proposer chose, data, not an instruction or a statement of fact. Slots are published once finalized, 13–19 minutes behind the chain head; a later slot is refused (`block_not_available`, `details.reason` `slot_not_published`, with `details.maxAvailableSlot`) — retry later. A slot is never answered as not existing. Use it to inspect one slot and who was due to propose it. Not for the execution block itself: pass `execution.blockNumber` to get_block. Not for every missed slot, newest first: use get_consensus_missed_slots. Arguments: slot. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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/consensus-slot
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| slot | integer | yes | The beacon slot. |
Structured output declared, but exposes no named fields.
No examples provided.
get_consensus_validator One validator ~376
One validator by its index in the consensus registry, as of the validator snapshot taken about once a day (`snapshotEpoch`): its status as the beacon chain names it, slashed, lifecycle epochs (an absent epoch is not scheduled), effective balance in gwei, public key, credential type, withdrawal credentials and `withdrawalAddress` — the execution address its payouts go to, a DESTINATION, not the owner or operator, absent for BLS credentials. An index above the snapshot is refused (`block_not_available`, `details.reason` `validator_beyond_snapshot`, with `details.maxAvailableValidatorIndex`): deposited after it, or not assigned yet — a snapshot cannot prove a validator does not exist. Use it to look up a validator's state and payout address. Not for its payouts (get_validator_withdrawals) or its proposals (get_consensus_validator_slots). Not for every validator paying out to one address: use get_entity_validators. Arguments: index. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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/consensus-validator
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| index | integer | yes | The validator's index in the consensus registry. |
Structured output declared, but exposes no named fields.
No examples provided.
get_consensus_validator_slots A validator's proposal history ~444
One validator's proposal history over every published slot, newest first: each slot it proposed (`outcome` `proposed`, with `executionBlockNumber`) and each slot it was assigned and no block was proposed in (`outcome` `missed`). Proposals are complete; misses are a lower bound, since assignments are recorded only from slot 14 971 296 on (`dutyStatus`). `truncated` says there are more than returned: raise `limit`, up to the newest 200 slots — older ones cannot be read here. An index that proposed nothing answers an empty list — a fact up to `publishedThroughSlot`, which trails the chain head by 13–19 minutes. Use it to audit one validator's proposals and misses. Not for its status and payout address (get_consensus_validator) or the network's misses (get_consensus_missed_slots). Arguments: index; optional limit (default 25, at most 200). `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: standard. Documentation: https://docs.tracefast.xyz/api/consensus-validator-slots
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| index | integer | yes | The validator's index in the consensus registry. |
| limit | integer | – | How many rows to return: 1 to 200, 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_contract One contract ~347
One deployed contract: the hash and size of its current code, what the code exposes (the four ERC-20 view functions, ERC-165, an EIP-1167 minimal proxy and its target), the proxy pattern detected in it, and its lifecycle — the deploying account, the creating transaction, code changes and self-destruction. An address with no indexed code is refused (`not_found`). Use it to learn how a contract is built. Not for the selectors in its code (get_contract_selectors), its implementations (get_contract_proxy) or the address as an account (get_entity_overview). Not for its code hashes and fingerprint in one place: use get_contract_identity. Not for how its code can change: use get_contract_security. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_bytecode Bytecode of a contract ~306
The current runtime bytecode of a contract as hex — up to 24 576 bytes of code — with its code hash and a structural fingerprint that is equal across contracts sharing the same logic. An address with no indexed code is refused (`not_found`). Use it to read or compare a contract's code. Not for a readable summary: use get_contract or get_contract_selectors. Not for its instructions one by one: use get_contract_disassembly. Not for the code as readable pseudocode: use get_contract_decompilation. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-bytecode
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_capabilities What a contract can do: mint, pause, blacklist, upgrade ~382
The powers of one contract, each answered as three separate questions — `inCode` (its code exposes the power), `availableNow` (it can be used right now) and `usedBefore` (it has been used on chain) — with the block each answer was evaluated at (`referenceBlock`). Powers include `mint`, `burn`, `pause`, `blacklist`, `freeze`, `seize`, `upgrade` and `emergency_withdraw`; others may appear. An answer is present only when it is proven: an absent answer means not proven, never "no". `otherFacts` lists the remaining proven capability facts by id (for example `capability:currently_paused`); `graphReached` false means TraceFast has not evaluated the address yet, so nothing here is an answer about it. Use it to check what an issuer or admin could do to a token or its holders. Not for how the code is built or can change: use get_contract_security. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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: core. Documentation: https://docs.tracefast.xyz/api/contract-capabilities
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_clones Contracts running exactly the same code ~506
Every contract running exactly the same code as this one — byte for byte, the same `codeHash` — in address order, each with the block its code was set at, plus `contractCount`, the size of the whole list. The same code says nothing about owner or deployer: factories, templates and copies produce identical code for unrelated parties, and clones can hold different state. Code that differs only in its metadata or constructor-set values is not listed: compare `fingerprint` from get_contract_identity. For an EIP-7702 account the shared code is the delegation, so the list is the accounts delegated to the same contract. The list is updated once a day: a contract deployed or changed since then, this one included, is missing or still listed under its earlier code. An address with no indexed code is refused (`not_found`). Use it to find other deployments of a known contract. Not for the contracts an address created: use get_entity_deployments. 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: a ranking recomputed daily; 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: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-clones
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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_contract_control_history Who changed a proxy's implementation or admin, and when ~505
Every write to a proxy's control slots — the EIP-1967 implementation, admin and beacon slots and the older OpenZeppelin slot — newest first, one row per write: the block and transaction, which `slot`, `oldValue` and `newValue`, who called the frame that wrote it (`callerAddress`) and whose code ran in it (`executionAddress`). `kind` is `upgrade` (a value written), `unset` (the slot written to zero) or `cleared` (wiped with the account by a pre-Cancun SELFDESTRUCT); other values may be added. An `upgrade` from an all-zero value means the slot was empty before, not necessarily the proxy's deployment. Changes of an owner role are not here: only the storage slots proxies use for control. Use it to see who upgraded a proxy or changed its admin, and when. Not for the implementations themselves with the blocks each was seen at: use get_contract_proxy. 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/contract-control-history
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The proxy, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | 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_contract_decompilation Decompiled code of a contract ~668
A contract's code reconstructed as readable Solidity-like pseudocode, for contracts with or without published source — by default the code that runs at the address (through a proxy, a beacon, a minimal proxy or an EIP-7702 delegation), at the latest block or at `block`. The answer is a table of contents of the functions, named where known; `selector` returns one function's body, `bodies` the bodies in order, a page at a time; the table of contents is paged too (about 512 KiB a page: `hasMore`, `nextCursor`); a body larger than 512 KiB as written comes without `text` (`textState` `withheld_for_size` and `textLength` instead). The reconstruction is best-effort and every answer says so. A code not analysed yet is analysed on request: the call is then refused (`decompilation_pending`) with `retryAfterSeconds` — call again after it, usually within a minute. Each account starts a limited number of analyses per day; reading an analysed code is not limited. Use it to understand what an unverified contract does. Not for the selectors its bytecode refers to: use get_contract_selectors. Not for the instructions behind a body's pcs: use get_contract_disassembly. Arguments: address; optional block, target, selector, bodies, 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/contract-decompilation
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| block | integer | – | The block to resolve the code at. Default: the latest covered block. |
| bodies | boolean | – | `true`: the first page of bodies in table-of-contents order. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| selector | string | – | One function's body: `0x` + 8 hex characters, or `fallback` / `receive`. Not with `bodies` or `cursor`. |
| target | string | – | `auto` (default): the code that runs at the address, one hop through a proxy. `self`: the address's own code (a proxy's own). |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_disassembly Disassembly of a contract ~511
A contract's code as EVM instructions with their byte offsets (pc), in order, a page at a time — the same pcs the decompiled view refers to. By default the code that runs at the address, through a proxy, at the latest block or at `block`. The compiler's metadata at the end of the code is named and every instruction inside it is marked: it is data that happens to decode as instructions. Use it to inspect a contract at the instruction level. Not for the raw code as hex: use get_contract_bytecode. Arguments: address; optional block, target, limit (default 500, at most 2000), 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-disassembly
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| block | integer | – | The block to resolve the code at. Default: the latest covered block. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | How many rows to return: 1 to 2000, default 500. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| target | string | – | `auto` (default): the code that runs at the address, one hop through a proxy. `self`: the address's own code. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_events Events emitted by a contract ~807
The event logs a contract emitted, newest first (`order` `asc` for oldest first) — each with its topics, data, transaction and position and, where the signature is known, the decoded event and arguments with a stated confidence (`decodeStatus`), plus the readings (`decoded.candidates`, at most 8; `candidateCount` is the true count) when more than one known signature fits. One event's readings are bounded in size: a value too large to include is `valueState` `withheld_for_size`, without `value` (the log's `data` carries its bytes), and a decoding stopped by its work budget before every known signature was tried says `decodeSearch` `incomplete` — `ambiguous` with a reading, no `decodeStatus` without one, never `failed`. A log whose data is longer than 49 151 bytes comes without `data`: `dataState` `withheld_for_size` and `dataLength` (bytes) instead, topics and decoding still given. A page holds at most `limit` events and may hold fewer when their data is large; a log is never cut. `topic0` narrows to one event signature, `eventName` to one event name and `fromBlock` / `toBlock` to a block window; on a very active contract `topic0` and `eventName` are answered only inside a window, and the refusal names the window it needs (`filter_needs_block_window`). Use it to read a contract's event history. Not for what one transaction emitted: use get_transaction_events. Arguments: address; optional limit (default 10, at most 100), cursor, topic0, eventName, order, 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 minut…
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| eventName | string | – | Only events whose name, as TraceFast's event index records it, is this value, e.g. `Transfer`: 1 to 100 letters, digits or underscores. Case-sensitive. An event the index holds no name for is not mat… |
| fromBlock | integer | – | Inclusive lower block bound. |
| limit | integer | – | 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. |
| order | string | – | `desc` (default): newest first. `asc`: oldest first — the start of the contract's history on the first page. |
| toBlock | integer | – | Inclusive upper block bound. |
| topic0 | string | – | The event signature hash to narrow to, `0x`-prefixed, 64 hex characters. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_function_calls Calls per function of a contract ~475
How often each function of an address was called — the transactions sent to it per 4-byte selector, most called first, with the block of the last call and the function's name where known — plus the first and the last block in which it received any call. Top-level calls only: a call made from inside another contract is not counted, and a proxy's calls are counted at the proxy. An address nobody called answers an empty list. At most the 1 000 most called selectors (`truncated` when more exist; `entryCount` is the whole list's), paged by bytes: about 448 KiB a page, a whole entry at a time; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`; a cursor from a list recounted since is refused (`invalid_cursor`: restart). Use it to see which functions of a contract are actually used. Not for the transactions themselves: use get_entity_transactions. Not for the calls one by one, internal ones included: use get_entity_calls_received. Arguments: address; 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: 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: Intelligence; the Investigation plan includes it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-function-calls
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_hot_slots The storage slots of a contract that changed most recently ~426
The 25 storage slots of a contract whose value changed in the most blocks of a recent window (`windowBlocks`, about a day by default, at most a week), each with how many blocks it changed in and the last of them, plus `totalSlotsInWindow`, every slot that changed. A change is a block in which the value differs: several writes in one block are one change, and a write of the value already held is none. A slot not listed changed in fewer blocks than the 25 listed, or not at all. The window ends at the newest block known (`windowToBlock`); an empty window answers an empty list with `lastChangeBlock`, the contract's newest change before it, where known. A window too wide to read right now is refused (`service_unavailable`); a `windowBlocks` no larger than `details.maxBacklogBlocks` is always answered. Use it to see which state of a contract is busy right now. Not for one slot's values over time: use get_contract_slot_history. Not for every declared variable with its current value: use get_contract_storage_parameters. Arguments: address; optional windowBlocks. `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: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-hot-slots
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| windowBlocks | integer | – | The window's width in blocks, 1 to 50400 (one week), default 7200 (about a day). |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_identity Which code a contract runs, its hashes, and how it came to be ~365
Which code a contract runs and how it came to be: the Keccak-256 hash of its current code (`codeHash`), the SHA-256 of the same code (`runtimeSha256`, the hash source verifiers such as Sourcify key on), a structural `fingerprint` equal across contracts sharing the same logic, the code's size and kind (`bytecodeVariant`), and its `lifecycle` — deploying and signing account, creating transaction, code changes and self-destruction. Fields not recorded are absent. For an account delegated by EIP-7702 the stored bytes are the delegation, not code, so `runtimeSha256` and `fingerprint` are absent. An address with no indexed code is refused (`not_found`). Use it to match a contract against verified source or other deployments. Not for other contracts with exactly this code: use get_contract_clones. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-identity
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_proxy Implementations of a proxy contract ~417
The implementations a proxy contract has been seen delegating to, newest first — read from its EIP-1167 bytecode, its EIP-1967 implementation or beacon slot, or its OpenZeppelin v1 slot — each with the blocks it was seen at and whether it has since been replaced. `supersededBy` has three states: absent when storage cannot say, `null` when the pointer is current, an address when it was replaced. For a beacon proxy the address listed is the beacon, and `beacon` says what that beacon handed out: each logic contract with its block range, newest first (`state: proven`), or `not_proven` when the beacon's implementation could not be established. An empty list means no pointer was seen, not that the address is not a proxy. Use it for a proxy's implementation history as its code and storage show it. Not for the relations TraceFast has proven: use get_entity_relations. Not for every write to its control slots, with who made it: use get_contract_control_history. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-proxy
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The proxy contract address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_security How a contract's code is built and how it can change ~363
How one contract's current code is built and how it can change: the proxy pattern detected in it (`proxyFamily`) with its confidence, its opcode-level features (`codeFeatures`: DELEGATECALL, CALLCODE, a DELEGATECALL target read from storage), and what TraceFast has proven about its architecture (`architecture`: for example immutable, an upgradeable proxy, a mutable implementation slot, metamorphic), each fact with its evaluation block. Only proven facts are stated: an absent one means not proven, never "no"; `graphReached` false means the address is not evaluated yet. An address with no indexed code is refused (`not_found`). Use it to judge whether a contract's behaviour can change under its users. Not for who changed a proxy's implementation and when (get_contract_control_history) or what the contract can do (get_contract_capabilities). Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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/contract-security
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_selectors Function selectors of a contract ~488
The 4-byte selectors found as constants in a contract's bytecode, each resolved to a known signature and function name where one exists, with how many known signatures share it and how confident the resolution is (`decodeStatus`). The list holds the contract's own functions together with the selectors of functions it calls on other contracts and of its custom errors, not told apart: a selector here is not proof the contract implements it. A known signature whose text is not served says `nameState: withheld`. Paged: at most 1 000 selectors and about 224 KiB a page; `hasMore` says the list goes on — pass `nextCursor` back as `cursor`. An address with no indexed code is refused (`not_found`). Use it to see which known functions and errors a contract's code refers to. Not for the calls it received (get_entity_transactions) or the events it emitted (get_contract_events). Not for how often each function was called: use get_contract_function_calls. Arguments: address; 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 contract as TraceFast's contract index holds it, refreshed in batches usually minutes behind the chain — a contract deployed since may not be found yet. 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-selectors
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_slot_history How one storage slot of a contract changed over time ~534
Every block in which one storage slot (`key`, 32 bytes) of a contract changed value, newest first — `valueBefore` and `valueAfter` the block, and the transactions that wrote the slot in it (`writerTxs`). One entry per block: several writes in one block are one change, and a write of the value already held is none. `valueAfter` is absent on the newest change when it is not stated, never a zero standing in; `writerTxs` is empty for a system write with no transaction, and absent until the block is attributed (usually seconds). `readThroughBlock` is the newest block the page was read through. A page can be shorter than `limit` and still continue: one call reads a bounded span of history. Use it to follow one variable of a contract over time. Not for finding which slots matter: use get_contract_hot_slots or get_contract_storage_parameters. Arguments: address, key; optional 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 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/contract-slot-history
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| key | string | yes | The 32-byte slot key, `0x` + 64 hex. |
| limit | integer | – | 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. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_storage_activity How a contract's storage was read and written, per day ~339
For each UTC day of a window (`days`, 90 by default, at most 365), oldest first, how many transactions touched a contract's storage, read it, wrote it, or only read it (a dependency on its state); the SLOAD and SSTORE opcode counts (reverted frames included — executions, not distinct slots); the transient-storage opcodes TLOAD and TSTORE; and the slot touches (distinct slots per transaction, summed). Only days with activity have a row: a missing day is not a stated zero. The last day is partial, through `readThroughBlock`. Use it to see how a contract's state is used over time and how many transactions read it without writing. Not for who writes it: use get_contract_storage_writers. Arguments: address; optional days. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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/contract-storage-activity
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| days | integer | – | The window in UTC days, 1 to 365, default 90. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_storage_parameters The direct storage slots of a contract (its declared variables) and their values ~528
The direct storage slots of a contract — the slots below 2^64 that hold its declared variables, packed fields and fixed-array elements, not mapping entries — in slot order, each with how many blocks changed it, the first and last of them, and its current value. `currentValueStatus` says whether the value can be stated: `observed` (then `currentValue`), `system_writes`, `ambiguous_order`, `storage_cleared`, `no_transaction_write`, or `not_computed` (the newest blocks are not processed yet: retry); `currentValue` is absent in every state but `observed`, never a zero. Variable names are not stated, and only slots whose value ever changed are listed: absence is not "no such variable". A contract with too many or too densely changed direct slots is refused (`storage_parameters_unavailable`) — read single slots with get_contract_slot_history. Use it to read a contract's configuration and state variables. Not for mapping entries such as balances: use get_contract_slot_history with the slot key. Arguments: address; optional limit (default 25, at most 200), 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: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-storage-parameters
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| cursor | string | – | `data.nextCursor` of this tool's previous answer, passed back unchanged with the same other arguments. Opaque; absent on the first call. |
| limit | integer | – | How many rows to return: 1 to 200, 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_contract_storage_profile Totals of a contract's storage writes ~323
The totals of every write to a contract's storage over its history: how many writes (`totalWrites`), distinct slots, callers and executing code addresses (estimates on large contracts), the first and last block written, how many writes ran through DELEGATECALL (`delegatecallWrites`, code borrowed from another contract as in a proxy) and their share, and the deepest call depth a write happened at. Refreshed hourly: the newest writes are not counted yet, and an address whose first write is that recent is refused (`not_found`) like one that never wrote. No names. Use it to size a contract's storage footprint at a glance. Not for who the writers are: use get_contract_storage_writers. Not for reads and writes day by day: use get_contract_storage_activity. Arguments: address. `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: Investigation. Rate class: core. Documentation: https://docs.tracefast.xyz/api/contract-storage-profile
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_contract_storage_writers Who writes a contract's storage ~400
The accounts that wrote a contract's storage, ranked by number of writes — each row a pair of the caller (`callerAddress`, who called the frame that wrote) and the execution address (`executionAddress`, whose code ran: the contract itself, or an implementation it delegated to) — with the writes, the transactions (an estimate on large contracts) and the first and last block. `totalPairs` counts every pair; the list is the top of the ranking only, ties broken by caller then execution address. The ranking is refreshed once a day, the counts and blocks hourly: a pair that started writing or moved up since then is not reflected yet. No names. Use it to find which accounts and code change a contract's state. Not for the totals: use get_contract_storage_profile. Arguments: address; optional 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 ranking recomputed daily; 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: Investigation. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/contract-storage-writers
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The contract, `0x` + 40 hex, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| limit | integer | – | 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_dex_volume_daily DEX volume per day, by protocol ~383
Per UTC day over a window of dates, oldest first: the DEX trading of each protocol — swaps, USD volume, active pools and the pools that could not be priced (`unpricedPools`) — and the day's totals. A USD volume adds only the pools that could be priced, so a figure beside `unpricedPools` is a partial sum, and it covers the pools TraceFast decodes, not every venue. `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. Days marked `provisional` may still change: today, and the last four days, whose USD values are revised once a day. Use it to chart DEX activity by protocol. Not for which tokens or pools traded most: use get_top_dex_tokens or get_top_pools. 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-dex-volume
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| from | string | – | The first UTC date, `YYYY-MM-DD`. |
| to | string | – | The last UTC date, `YYYY-MM-DD`. Default: today. |
Structured output declared, but exposes no named fields.
No examples provided.
get_entity_activity Activity of an address ~312
When an address was active, as three separate answers: when it was first mentioned anywhere on chain; when its own account state last changed and how many times; and the newest block at which it took part in anything (a top-level transaction, a token transfer, an emitted log, a value-bearing call), with the sources that answer covers. Read `lastActivity` as "last active": a contract only ever called by other contracts never changes its own state after deployment. Use it to date an address. Not for who it deals with: use get_entity_counterparties. Not for activity day by day: use get_entity_daily_activity. Not for the transactions themselves: use get_entity_transactions. 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: standard. Documentation: https://docs.tracefast.xyz/api/address-activity
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_entity_attribute_history Attribute history of an address ~407
Every attribute interval an address has held, oldest first — when it became a contract, when its code was removed, when it first held state — each with the blocks it started and ended at. Covers the attribute families listed in `coveredFamilies`; an empty or short timeline says nothing about other families. Intervals of the `behavior` family state an observed pattern, not a verdict, and the most recent of them may shorten or disappear as later blocks are evaluated. `truncated` is true when the timeline was cut at `limit`: ask again with a larger `limit` (the maximum holds the whole timeline of the busiest address). Use it for "since when" and "until when". Not for the current set: use get_entity_attributes; for one past block use get_entity_attributes_at_block. 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 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-attribute-history
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| limit | integer | – | 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_entity_attribute_proof Proof of one attribute of an address ~333
The evidence behind one proven attribute of an address — the facts that were 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 — so the claim can be checked rather than trusted. `attribute_id` is an id get_entity_attributes lists in `attributes` (`family:name`; `attributeId` in its details). An attribute with no recorded proof is refused (`not_found`). Use it to verify why TraceFast states an attribute. Not for the attributes themselves: use get_entity_attributes. Arguments: address, attribute_id. `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-attribute-proof
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| attribute_id | string | yes | The attribute id, `family:name`, as listed by the attributes method. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_entity_attributes Attributes of an address ~345
The facts TraceFast has proven about an address now — what kind of account it is, how it has been used, what it is known to be: the proven attribute ids (`family:name`), each with its evaluation result and the block it was evaluated at, and, while the address is not evaluated yet, a provisional classification from on-chain evidence. An absent attribute is not proven; absence never means the opposite. Use it to learn what an address is. Not for the past: use get_entity_attributes_at_block or get_entity_attribute_history; not for balances or activity: use get_entity_overview. For the evidence behind one proven attribute, use get_entity_attribute_proof. Not for a contract's powers (mint, pause, blacklist, upgrade) arranged per power: use get_contract_capabilities. Arguments: address. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). 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: core. Documentation: https://docs.tracefast.xyz/api/address-attributes
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_entity_attributes_at_block Attributes of an address at a block ~338
The attributes an address held at the end of one past block, each with the window it held for. Answered from the attribute history, which covers the families listed in `coveredFamilies` and the single ids listed in `coveredAttributeIds`: any other attribute is not listed whether or not it held, so its absence is not a negative — compare with get_entity_attributes for those. `behavior` is in `coveredFamilies` only for a block the family has been computed to. Use it for "what was this address at block N". Not for the current set (get_entity_attributes) or the whole timeline (get_entity_attribute_history). 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-attributes-at-block
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| block | integer | yes | The block to answer about. Required. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
Structured output declared, but exposes no named fields.
No examples provided.
get_entity_balance_history Native balance history of an address ~423
The native ETH balance of an address at the end of each day it changed, oldest first — with the day's net change, its balance-changing events and the USD value at the day's last hour (none for the current, unfinished day) — plus totals over the days returned: start and end balance, minimum and maximum, and inflow / outflow as sums of the days' NET changes — ether that arrived and left within one day is not counted in either, so they are not gross amounts received or sent. Days without a change have no point; `limit` counts the most recent days with a change. Use it to chart an address's ETH balance over time. Not for token balances (get_entity_portfolio) or the balance now (get_entity_overview). Not for every block that changed the balance, nonce or code: use get_entity_state_changes. Arguments: address; optional limit (default 30, at most 365). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. 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: Enriched Data; the Intelligence and Investigation plans include it. Rate class: standard. Documentation: https://docs.tracefast.xyz/api/address-balance-history
| Name | Type | Req | Description |
|---|---|---|---|
| address | string | yes | The address, `0x`-prefixed, 40 hex characters, any case. |
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| limit | integer | – | How many rows to return: 1 to 365, default 30. 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.
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
claude mcp add --transport http xyz-tracefast-mcp 'https://tracefast.xyz/mcp'
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.