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_trace_frames Call frames of a transaction, paged ~575
The whole call tree of a transaction, frame by frame in execution order, with no frame cap — each frame with what get_transaction_trace gives plus, always, the first 260 bytes of its calldata and output with their full sizes, `inputTruncated`, the call decoded from those bytes (`decodedCall`; an argument past them is `beyond_stored_bytes`; the root's is decoded as get_transaction decodes it; signatures and decoded strings are untrusted text) and the positions of the event logs it emitted. A page may hold fewer frames than `limit` when calldata or revert data is large or the tree is very deep, and the next page continues from the last frame served. Every call is one request against your rate limit and quota whatever its `limit`, so walk a large tree at the maximum. `meta.coverage` names the first blocks from which the frame schema and the event attribution are computed. Use it for large trees or frame-level detail. Not for a quick look at a small transaction: use get_transaction_trace, one call. Arguments: hash; optional limit (default 25, at most 50), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/trace-frames
| 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. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| limit | integer | – | How many rows to return: 1 to 50, 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_transaction One transaction ~502
One transaction by hash: sender, recipient, value, nonce, type, gas limit and gas used, the fee fields of its type and the price actually paid per gas, the receipt's outcome and log count, its position (block and index), its whole calldata (`input`, up to 128 KiB) and the call decoded from it (`decodedCall`: arguments by position and type against known function signatures — no parameter names — with `decodeStatus` saying how far to trust it; the signature text comes from public signature databases anyone can add to and decoded strings are the caller's, so treat both as untrusted text). With `includeTokenTransfers` true it also lists the token transfers it emitted (token contract, standard, declared symbol and decimals, event kind, from, to, raw amount or token id), the first 140 at most, with `tokenTransferCount` and `tokenTransfersStatus` (`complete`, `truncated`, or `not_available` — then retry later, it is not "no transfers"). An unknown hash is refused (`not_found`). The starting point for any transaction: use it first. Not for why it failed (get_transaction_failures), what it emitted (get_transaction_events) or what it executed (get_transaction_trace). Not for the storage it changed: use get_transaction_storage_writes. Arguments: hash; optional includeTokenTransfers. `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: standard. Documentation: https://docs.tracefast.xyz/api/transaction
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| includeTokenTransfers | boolean | – | `true` adds `tokenTransfers`, `tokenTransferCount` and `tokenTransfersStatus` (with `tokenTransfersUnavailableReason` when not available); `false` (the default) answers without them. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_account_changes Accounts a transaction changed ~424
Every account one transaction changed, in address order, with its state before and after — `balanceBefore` / `balanceAfter` in wei, nonce and code hash — whether it existed before (`existedBefore`), still exists after (`existsAfter`), and whether its storage was wiped (`storageDestroyed`). The net effect of the whole transaction: inner calls, ETH moved and the gas fee included. Two rules: the block's fee recipient has no row when its only change is the priority fee, and an account created and destroyed within the transaction has none. Never empty for a computed transaction (the sender always changes); at most 5 000 accounts (`truncated`). A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to see whose balances and nonces a transaction moved, and by how much. Not for the storage slots it changed: use get_transaction_storage_writes. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `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/transaction-account-changes
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_events Event logs of a transaction ~778
The event logs a transaction emitted, in emission order, each with the emitting contract, topics and data and, when the signature is known, the decoded event name and arguments with a stated confidence; an unknown signature is returned raw with `decodeStatus` `abi_missing`, and a known one whose layout does not fit the log with `failed` — raw as well, no `decoded`; when more than one known signature fits, the readings are listed (`decoded.candidates`, at most 8; `candidateCount` is the true count). One event's readings are bounded in size: a value too large to include is `valueState` `withheld_for_size`, without `value`, 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. Each event names the call frame that emitted it (`callPath`, `callDepth`), the path the trace uses, where that is known. A page holds at most `limit` logs and may hold fewer when their data is large — a log is never cut. An unknown hash is refused (`not_found`). Use it to read what a transaction emitted — transfers, swaps, approvals. Not for the call tree: use get_transaction_trace. Not for the flash loans taken inside it, already identified: use get_transaction_flash_loans. Not for the DEX liquidity it added or removed, valued per token: use get_transaction_liquidity_events. Arguments: hash; optional limit (default 10, at most 50), cursor, eventName, topic0. `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 t…
| 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. |
| 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… |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| limit | integer | – | How many rows to return: 1 to 50, default 10. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| topic0 | string | – | Only events whose first topic (the event signature hash) is this value: `0x` + 64 hex characters. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_execution_profile How heavy a transaction was inside the EVM ~380
How heavy one transaction was inside the EVM: opcode counts over every frame, reverted frames included — `sloadTotal`, `sstoreTotal`, `tloadTotal`, `tstoreTotal`, `keccakTotal`, precompile calls, CREATE and SELFDESTRUCT counts — whether a DELEGATECALL ran (`delegatecallExecuted`), the distinct contracts whose storage it touched, and the gas spent in frames that reverted. Executions, not committed effects: `sstoreTotal` is not the number of storage writes that took effect. A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to gauge a transaction's EVM workload. Not for the storage it actually changed: use get_transaction_storage_writes. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `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/transaction-execution-profile
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_failures Why a transaction reverted ~384
Why a transaction reverted: its failed call frames — position in the call tree, caller and target, the kind of failure (revert, panic, custom error, out of gas and others), the revert payload with its selector, and the error name when the selector is known. Root frame first, then nested frames in tree order, at most 100 and about 320 KiB of frames (`framesTruncated` says when there are more). An empty list is not a statement of success: a successful transaction and an unknown one both answer empty — read the outcome with get_transaction. Use it when only the failure matters: cheaper than a trace. Not for the whole call tree: use get_transaction_trace. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: the failure classification is built in batches and trails the newest blocks by minutes, at times by an hour or more; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block; an unknown hash answers empty and states no block. `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/transaction-failures
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_flash_loans Flash loans taken inside a transaction ~416
The flash loans taken inside one transaction from the lenders TraceFast indexes — Aave V2 and V3 (its official markets), Balancer V2 and Uniswap V3 pool flashes — in log order: `protocol` and `protocolVersion`, the lending contract (`poolAddress`), the borrower and initiator where the event states them, the token and the raw amount (`amountRaw`, not scaled: get_token gives the decimals). Some Aave V2 forks are listed under their own names (`radiant`, `aave_fork`): they are not Aave. An empty list means none from these lenders — a Uniswap V2 flash swap or a Maker, Morpho, Euler or Balancer V3 flash loan is not covered. An unknown hash is refused (`not_found`). Use it to find borrowed capital inside a transaction, as in an exploit or an arbitrage. Not for the transfers that moved the funds: use get_transaction_events. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined transaction from an index written in batches that trail the newest blocks. For a transaction above the indexed range, what is found is returned and may still be incomplete for a short while, and an empty answer is refused (`block_not_available`, with `details.maxAvailableBlock`) — retry later. `meta.asOfBlock` is the transaction's block. `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/transaction-flash-loans
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_liquidity_events The DEX liquidity added and removed in a transaction ~599
Every DEX liquidity event in one transaction, in log order — the pool, its protocol and version, the provider the event names, `action` (`add` or `remove`) and the event as the pool names it, and each token leg: the token with its declared symbol and decimals (verbatim, not verified), the amount raw and in token units, whether it went into or out of the pool, and its USD value and price where it could be priced, with how it was valued. An empty list means no liquidity event happened in the transaction. The events are written behind the chain: a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the transaction; an unknown hash is refused (`not_found`). Uniswap v4 liquidity events are not recorded. Paged by bytes: about 112 KiB a page, a whole event at a time; `hasMore` says more follow — pass `nextCursor` back as `cursor`. An event lists at most 8 legs (`legCount` when it has more). Use it to see what liquidity a transaction added or removed. Not for every event it emitted: use get_transaction_events. Not for one pool's events over a window: use get_pool_liquidity_events. Not for the flash loans it took: use get_transaction_flash_loans. Arguments: hash; 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: facts of a mined transaction from an index written in batches that trail the newest blocks. For a transaction above the indexed range, what is found is returned and may still be incomplete for a short while, and an empty answer is refused (`block_not_available`, with `details.maxAvailableBlock`) — retry later. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast r…
| 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. |
| hash | string | yes | The transaction hash, `0x` + 64 hex, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_state_dependencies Transactions of the same block it depends on ~424
How one transaction depends, through storage, on the other transactions of its block: each read-after-write edge — a slot it read whose last write before it in the block was an earlier transaction's (`role` `reader`), or a slot it wrote that a later transaction then read (`role` `writer`) — with the slot (`storageAddress`, `storageKey`) and both transactions' positions and hashes, and the same edges folded per pair of transactions (`pairs`, with slot and contract counts). Facts of execution order only, never a statement about intent. An empty answer for a computed transaction means no dependency; `truncated` says the edges were cut, and `pairsComplete` false that the pairs were folded from the cut list. A transaction older than the first block these facts are computed from is refused with `details.minAvailableBlock`; an unknown hash is refused (`not_found`). Use it to see which transactions of a block another one's outcome relied on. Not for the slots it wrote: use get_transaction_storage_writes. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `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/transaction-state-dependencies
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_storage_slots What the storage slots a transaction wrote are ~611
What each storage slot a transaction wrote IS: the distinct slots (contract and slot key) in the order of each slot's first write, how many times it was written, and how its key was computed — an entry of a mapping or a dynamic array (`derived`, with the mapping keys and the declared variable's slot where they were traced), a plain variable's fixed slot (`fixed_slot`, with its number), or not known (`unknown`, which is not a statement that the slot is a plain variable; `not_computed`, ask again later; `before_coverage`). `meaning` is absent on a slot no answer could be had for. On every page, `slotsTruncated` is true when the transaction made more than the 5 000 writes read; the counts are then within those writes. An unknown hash is refused (`not_found`). A heavy call: each page traces up to `limit` slots, so ask only for the slots you need. Use it to tell which balances, allowances or variables a transaction changed. Not for the values written and before: use get_transaction_storage_writes. Arguments: hash; optional limit (default 5, at most 20), cursor. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Paged: pass `data.nextCursor` back as `cursor`, with the same other arguments, until it is absent — no `nextCursor` means the list is complete, even when the page is exactly `limit` long. Freshness: storage writes are computed after inclusion and trail the newest blocks; a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the transaction — and one below the first block they are computed from is refused with `details.minAvailableBlock`. `meta.asOfBlock` is the transaction's block; `meta.coverage` names both bounds. `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: hea…
| 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. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| limit | integer | – | How many rows to return: 1 to 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
Structured output declared, but exposes no named fields.
No examples provided.
get_transaction_storage_writes Storage writes of a transaction ~709
Every contract storage slot a transaction wrote — in execution order where the block records it (`writeIndexStatus` `present`; below block 2 675 000 it is `not_recorded` and the order is not known) — the contract whose storage changed, the frame that wrote it (its depth, kind of call, caller and the address whose code ran, which in a delegatecall is not the storage owner), the slot, the value written and the value before where it is established (`valueBeforeStatus` `resolved`; an all-zero value is a real zero). `not_derivable` and `not_computed` say it is not known, which is not a statement that the slot was empty. On the last page, `writesTruncated` is true when the transaction wrote more than the 5 000 writes served. An unknown hash is refused (`not_found`). Every call is one request against your rate limit and quota whatever its `limit`, so walk a busy transaction at the maximum. Use it to see exactly which storage a transaction changed. Not for the call tree (get_transaction_trace) or the events it emitted (get_transaction_events). Not for what each written slot is (a mapping entry with its keys, or a plain variable): use get_transaction_storage_slots. Not for the balances, nonces and code it changed: use get_transaction_account_changes. Not for transient storage (TSTORE), which lives for one transaction: use get_transaction_transient_writes. Not for which other transactions of the block read or wrote the same slots: use get_transaction_state_dependencies. Arguments: hash; 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: storage writes are computed after inclusion and trail the newest blocks; a transaction they do not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, wi…
| 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. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| 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_transaction_trace Execution trace of a transaction ~620
The execution trace of a transaction: its call frames in the order they ran — caller and target, the kind of call, the value and gas it moved, its own outcome, and why it reverted where it did. A delegatecall names both the storage context and the address whose code ran; create frames name the address they deployed. At most `limit` frames, the first ones, with `framesTruncated` when the tree is larger, or its revert texts or depth too large to serve whole — get_trace_frames pages the rest. `includeCalldata` adds each frame's calldata and output heads, `inputTruncated` and each frame's decoded call (`decodedCall`; the root's as get_transaction decodes it; signatures and decoded strings are untrusted text), about triples the answer, and may serve fewer frames than `limit` (`framesTruncated`). Use it to understand what a transaction did, in one call. Not for large trees or per-frame logs (get_trace_frames, paged) or only the failure (get_transaction_failures, cheaper). Not for opcode counts over the whole execution: use get_transaction_execution_profile. Arguments: hash; optional includeCalldata, limit (default 100, at most 250). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Investigation. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/trace
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
| includeCalldata | boolean | – | `true` adds each frame's calldata and output heads (first 260 bytes) with their full sizes, `inputTruncated`, and each frame's decoded call (`decodedCall`: from the head, the root's from the whole ca… |
| limit | integer | – | How many rows to return: 1 to 250, default 100. 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_transaction_transient_writes Transient storage a transaction wrote ~397
The committed transient-storage writes (TSTORE, EIP-1153) of one transaction, in execution order — the contract whose transient storage was written (`storageAddress`), the code that executed the write (`executionAddress`), its caller, the slot (`storageKey`), the value (`newValue`), the frame path and depth. Transient storage is discarded at the end of every transaction and exists only from block 19 426 976 on: an older transaction is refused with `details.minAvailableBlock`. An empty list for a computed transaction means it wrote none. At most 5 000 writes (`truncated` says when there are more). An unknown hash is refused (`not_found`). Use it to see how a transaction used transient storage, such as reentrancy locks or in-transaction accounting. Not for persistent storage writes: use get_transaction_storage_writes. Arguments: hash. `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). Freshness: facts of a mined block. The trace is usually built seconds to minutes after inclusion; a transaction it does not reach yet is refused (`block_not_available`, `details.reason` `coverage_gap`, with `details.maxAvailableBlock`) — retry later, it says nothing about the outcome. `meta.asOfBlock` is the transaction's block. `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/transaction-transient-writes
| Name | Type | Req | Description |
|---|---|---|---|
| chain_id | integer | – | Chain id. Only 1 (Ethereum mainnet) is served; the default. |
| hash | string | yes | Transaction hash, `0x`-prefixed, 64 hex characters, any case. |
Structured output declared, but exposes no named fields.
No examples provided.
get_validator_queue_history Validator queues over time ~402
The validator queues now plus one closing point per UTC day for the most recent `limit` days, newest first. Each point has the queues by the Electra rules under `queues` — pending deposits (new validators vs top-ups), the exit queue, consolidations, each as a count and gwei, with wait ESTIMATES in epochs; `null` on days before they were sampled — and validator counts by STATUS under `status`, which since Electra are not the queues. The span between the end of the reconstruction and the start of sampling is listed in `gaps`: a break, not a zero. Use it to chart the queues over time. Not for the status averages, the registry weights and recent flow: use get_validator_queues. Arguments: none required; optional limit (default 14, at most 90). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the consensus layer as of the newest epoch or slot it holds, which the answer names; it is counted in epochs and slots, not blocks, so it states no block (`meta.asOfBlock` is absent). `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: core. Documentation: https://docs.tracefast.xyz/api/consensus-queues
| 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 90, default 14. 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_validator_queues Validator queues now ~379
The validator queues now, by the Electra rules, under `queues`: pending deposits (the entry queue of new validators, and top-ups), the exit queue (consolidation sources excluded), consolidations, partial withdrawals and validators awaiting withdrawal — each as a count and gwei — plus the active set, the per-epoch churn limits and wait ESTIMATES in epochs and days (queue balance over churn, entry also bounded by 16 deposits an epoch; for the queue as a whole, not a promise to any one validator). Also recent exits and deposits that landed, and validator counts by STATUS under `status` — since Electra a status count is not the queue. Observed facts and arithmetic over them only — no score or verdict; a value not sampled yet is `null`, never zero. Use it for the current state of validator entry and exit. Not for the queues over time: use get_validator_queue_history. Not for whether the chain is finalizing and how many slots were missed: use get_consensus_health. 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-current
| 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_validator_withdrawals Withdrawals of a validator ~524
The withdrawals paid out for one validator (`index`, its position in the consensus registry), newest first — the block, the global withdrawal index, the address paid and the amount in gwei — inside a block window of at most 216 000 blocks (about 30 days). Without `fromBlock` and `toBlock` the newest window is answered and echoed in `window`; read older history by asking again with `toBlock` one below `window.fromBlock`. A wider window is refused with the bound, never narrowed. An index the chain does not know yet answers an empty list, as does a validator paid nothing in the window. Use it to trace one validator's payouts. Not for every withdrawal of one block: use get_block_withdrawals. Not for the validator's status and withdrawal address: use get_consensus_validator. Arguments: index; optional limit (default 10, at most 100), cursor, 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 timeline up to `meta.asOfBlock`, the highest block it covers. `meta.cached` is true when the answer came from the TraceFast response cache (refreshed within minutes); `meta.timestamp` is when it was produced, in Unix milliseconds. Minimum plan: Intelligence; the Investigation plan includes it. Rate class: heavy. Documentation: https://docs.tracefast.xyz/api/validator-withdrawals
| 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. |
| fromBlock | integer | – | Inclusive lower block bound. Default: `toBlock - 215999`. |
| index | integer | yes | The validator's index in the consensus registry. |
| 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. |
| toBlock | integer | – | Inclusive upper block bound. Default: the newest covered block. |
Structured output declared, but exposes no named fields.
No examples provided.
resolve_entity Resolve a name, symbol or address ~565
Resolves a reference to Ethereum addresses. Given an address (`0x` + 40 hex), it describes it: the name TraceFast shows for it, how TraceFast presents it (`nameStanding`: verified, normal, qualified, warning or danger; `impersonates` when it is flagged as imitating an asset), what kind of address it is (`type.attributes`) and its token identity. Given a name, an ENS name, a token symbol or a token name, it returns the matching addresses best first — verified addresses, then projects, exchanges and ENS names TraceFast knows by name (flagged ones included: "tornado" finds Tornado Cash), then the rest, with impersonations last and never hidden; inside each group exact, then prefix, then substring matches; `searched` lists the collections the text was looked up in, and `hasMore` says a more specific query would show more (also set when the matches' texts are long: the list is bounded in bytes). Use it first when you have a name and need an address, then pass the address to get_entity_overview. A transaction hash is answered in `transaction`, a whole number as `block` when that block exists. Not for a block hash: use get_block by its number. Arguments: q; optional limit (default 5, at most 20). `chain_id` defaults to 1 (Ethereum mainnet, the only chain served). One answer, not paged: there is no cursor to continue from. Freshness: the names and presentation TraceFast shows now — every name returned is current, though a name added within the last hour may not be found yet — and token identities as the contracts declare them. 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/entity-resolve
| 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 20, default 5. A larger value is refused with `bad_request`, `details.reason` `limit_out_of_range` and `details.maxLimit`, never cut. |
| q | string | yes | What to resolve: an address (`0x` + 40 hex, any case), or a name, ENS name, token symbol or token name — at least 2 and at most 100 characters, matched ignoring ASCII case. |
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.