List your agent

TraceFast

MCP server● Hosted · onlinev0.2.0+acd465fb

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

Reviews

No review yet. Used TraceFast? Be the first to help others choose.

What it does

TraceFast is an MCP server, a connector that lets an AI assistant use it as a tool. It is hosted: an assistant connects to it over the internet, nothing to install.

No capability identified yet from its description.

Facts come from the Official MCP Registry, as declared by the publisher. Capabilities are matched automatically (low confidence). None of this is a test of the tool.

At a glance

Hosted (remote)YES
Local installNO
Version0.2.0+acd465fb
PriceNot in the registry
First seen14 Nov 2026
Last checked3h ago

How to connect

As declared in the Official MCP Registry · hosted endpoint tested by Electra Index 3h ago (live check)

Hosted endpoint

  • https://tracefast.xyz/mcp streamable-http

In Claude Code: claude mcp add --transport http tracefast https://tracefast.xyz/mcp

MCP settings (Claude Desktop, Cursor and other MCP clients)

{
  "mcpServers": {
    "tracefast": {
      "url": "https://tracefast.xyz/mcp"
    }
  }
}

Live check

Electra Index connected to the hosted endpoint 3h ago

ONLINE TraceFast answered an MCP connection on 17 Nov 2026 and introduced itself as xyz.tracefast/mcp 0.2.0+acd465fb (MCP protocol 2025-11-25).

109 tools offered to AI assistants

  • get_blacklist_events · 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 ev
  • get_blacklist_feed · 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 we
  • get_blacklist_issuers · 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 i
  • get_blacklist_status · 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 — pl
  • get_blacklisted_addresses · 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 a
  • get_blobs_daily · 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
  • get_block · 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 an
  • get_block_addresses · 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`, t
  • get_block_at_time · 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
  • get_block_authorizations · 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 `authorityStatu
  • get_block_internal_transfers · 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 transacti
  • get_block_participants · 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,
Show 88 more
  • get_block_proposers · 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 an
  • get_block_token_transfers · 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 (`tokenStan
  • get_block_transactions · 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 rec
  • get_block_withdrawals · 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 w
  • get_consensus_epochs · 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, B
  • get_consensus_health · 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 (`m
  • get_consensus_missed_slots · 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
  • get_consensus_slot · 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
  • get_consensus_validator · 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 ba
  • get_consensus_validator_slots · 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 a
  • get_contract · 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 acc
  • get_contract_bytecode · 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`)
  • get_contract_capabilities · 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
  • get_contract_clones · 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 ow
  • get_contract_control_history · 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 t
  • get_contract_decompilation · 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 t
  • get_contract_disassembly · 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`. T
  • get_contract_events · The event logs a contract emitted, newest 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`). A page holds at most `limit
  • get_contract_function_calls · 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 recei
  • get_contract_hot_slots · 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`,
  • get_contract_identity · 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 acro
  • get_contract_proxy · 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 h
  • get_contract_security · 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
  • get_contract_selectors · 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
  • get_contract_slot_history · 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
  • get_contract_storage_activity · 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 (reverte
  • get_contract_storage_parameters · 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, a
  • get_contract_storage_profile · 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
  • get_contract_storage_writers · 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,
  • get_dex_volume_daily · 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 coul
  • get_entity_activity · 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 transactio
  • get_entity_attribute_history · 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 `coveredFami
  • get_entity_attribute_proof · 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 w
  • get_entity_attributes · 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
  • get_entity_attributes_at_block · 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`: an
  • get_entity_balance_history · 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
  • get_entity_calls_received · Every transaction with a call frame in this address's context — it was called, as the transaction's own target (`transactionTarget`) or from inside another contract, reverted or not, with or without ETH — newest first: the block, the transa
  • get_entity_counterparties · The addresses one address has interacted with most, ranked by successful transactions across top-level transactions (with or without ETH, so a called token contract counts), internal ETH transfers and token Transfer events (as emitted: not
  • get_entity_daily_activity · For each day of a window (`period`: `30d`, `90d` by default, or `365d`), how many blocks changed an address's own account state and what changed — balance, nonce (transactions sent), code, creation — plus the window's active days and total
  • get_entity_deployments · Every contract creation an address made — each successful CREATE or CREATE2 frame it called — oldest first: the created contract, the block, the transaction, `callType`, the code it deployed (`codeHash`, `isEip1167Proxy`) and the wallet tha
  • get_entity_dex_trades · The DEX swaps an address sent or received the output of, newest first — the venue (`protocol`, `protocolVersion`), the pool (`poolAddress`, or `poolId` for a pool with no address of its own), the tokens sold and bought with their raw amount
  • get_entity_internal_transfers · The value-carrying calls an address sent or received inside transactions, newest first — each with its position and depth in the call tree, the kind of call, the value moved in wei, the other party and the frame's own outcome. The transacti
  • get_entity_overview · One address as the chain sees it now: how it exists (an account whose state was touched, or an address only ever mentioned by other operations), whether it holds code, for an account whether it delegates its code with EIP-7702 (`eip7702`: t
  • get_entity_portfolio · What an address holds, valued in USD: its token balances and native ETH, each with the balance, the hourly USD price, the USD value and the share of the total, in descending USD value — plus `totalUsd`, `pricedCount` and `hiddenCount` over
  • get_entity_relation_history · Every relation interval an address has held, oldest first (`order` `desc`: newest first) — as the subject (what it pointed at, the default) or as the object (who pointed at it) — each with the blocks it started and ended at. Covers the rela
  • get_entity_relation_proof · The evidence behind one proven relation between two addresses — the facts checked with their expected and observed values, the conditions that had to be false, opaque ids of the sources read, and the block and block hash the evaluation was
  • get_entity_relations · The relations an address holds now — which implementation a proxy points at, which beacon it reads, who administers it, where an account has delegated, which lending market lists a token — as the subject (what it points at, the default) or
  • get_entity_relations_at_block · The relations an address was the subject of at the end of one past block — which implementation a proxy pointed at, which beacon it read, who administered it, where an account had delegated — each with the window it held for. Covers the rel
  • get_entity_state_changes · The history of one account's own state, newest first — one entry per block that changed its balance, nonce or code, with the values before and after the block (`balanceBefore` / `balanceAfter`, nonce, code hash) and whether the account was
  • get_entity_token_balance · The balance of one token on one address — what `balanceOf` returns at the end of a block; a balance of "0" is a real zero. Served for the covered tokens (a growing set); another token is refused (`token_not_covered`) rather than answered wi
  • get_entity_token_transfers · The token transfers an address sent or received, newest first — ERC-20, ERC-721 and ERC-1155 transfers and the other value events get_token_transfers lists under `eventType` — each with the token as its contract declares itself (a symbol su
  • get_entity_transactions · The transactions an address sent or received, newest first — each with sender, recipient, value, fee, the called function where its selector is known, the outcome, and this address's side (`role`: sender, receiver, or self when it is both).
  • get_entity_validators · The validators that direct their withdrawals to an address, as of the validator snapshot taken about once a day (`snapshotEpoch`): counts over ALL of them whatever `limit` (`validatorCount`, active, withdrawn, slashed, by credential type, a
  • get_gas_daily · Per UTC day over a window of dates, oldest first: the effective gas price transactions paid (average, median, 10th and 90th percentile, wei), the priority fee (average and median, wei) and how many transactions there were of each type — leg
  • get_largest_liquidity_removals · The largest removals of liquidity from DEX pools over a window of blocks ending at `meta.asOfBlock` (`window`: `24h`, `7d` by default, or `30d`; the blocks are echoed as `fromBlock` / `toBlock`), largest USD first — each with the pool, its
  • get_latest_block · The newest block TraceFast serves, with its header and the totals of what it contains — transaction counts by outcome, gas, fees, value moved, withdrawals. Use it to learn the current height before asking about recent data. Not for a given
  • get_lending_market_config · The risk configuration of every asset of a lending protocol's markets, or of one with `asset`, as the protocol's last configuration events set it — loan-to-value, liquidation threshold, reserve factor and liquidation protocol fee in basis p
  • get_network_daily · Per UTC day over a window of dates, oldest first, the network's totals: blocks (count, first and last), transactions (all, successful, failed, contract creations) and the ETH they moved, gas used and the average block's utilization, the ave
  • get_new_accounts_daily · Per UTC day over a window of dates, oldest first: how many externally owned accounts (`newEoas`) and how many contracts (`newContracts`) appeared on the chain for the first time. `from` and `to` (`YYYY-MM-DD`) set the window, at most 366 da
  • get_new_pools · DEX pools in the order of their first swap, newest first — the pool (its address, or `poolId` for a Uniswap v4 pool), its protocol and version, and its first swap's block, time, transaction, tokens and amounts in token units. A pool appears
  • get_pool · One DEX pool by its address or, for a pool without one, its 32-byte id (a Uniswap v4 PoolId) — its protocol and version, its tokens with the symbol, name and decimals each token contract declares (verbatim, not verified), the fee tier and t
  • get_pool_liquidity_events · The liquidity events of one DEX pool inside a block window, newest first — the block, time and transaction, the provider the event names, `action` (`add` or `remove`) and the event as the pool names it, and the USD added or removed over the
  • get_pool_liquidity_flow · Per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first: the USD value of the liquidity added to and removed from a DEX pool and the net flow, the add and remove events and the
  • get_pool_reserves · What a DEX pool holds now, token by token — the raw reserve, the amount in token units where the decimals are known, and its USD value where the token has a price TraceFast trusts at that size — and `totalTvlUsd`, the USD total over the leg
  • get_pool_swaps · Every swap of one DEX pool, newest first — the block, time and transaction, the sender and recipient as the pool's event states them (the sender is often a router), the token sold in and the token bought out with raw amounts, decimals and t
  • get_pool_volume · A DEX pool's trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — USD volume, swaps, the volume of each of its two tokens in token units and how many distinct addre
  • get_pools_for_pair · Every DEX pool that holds both `tokenA` and `tokenB` — in either order, including pools of three or more tokens that hold both — newest created first, each with its protocol and version, fee tier where recorded (absent does not mean no fee)
  • get_signal_kinds · The vocabulary of TraceFast's detector signals: every kind get_signals serves as a row (`rowKinds`), each with the detector that raises it, whether it is always in the trader view (`alwaysTrader`) and the evidence fields it carries (`a.b` m
  • get_signal_rates · Over the same 7 200 blocks as get_signals (about 24 hours, ending at `meta.asOfBlock`): how many signals were raised of each kind get_signals does not list (`counts`; the `countedKinds` of get_signal_kinds always appear, zero included), fla
  • get_signals · The signals TraceFast's detectors raised over the last 7 200 blocks (about 24 hours, ending at `meta.asOfBlock`), newest block first. A signal is a detector's fast hypothesis about what it saw on chain, never a fact about an address: read i
  • get_token · One token contract: its standard as observed from its events (erc20, erc721, erc1155), the symbol, name and decimals it declares (verbatim, not verified), its all-time transfer count, how many addresses hold it now (`holderCount`, the same
  • get_token_dex_volume · A token's DEX trading per UTC day over the last `days` days (30 by default, up to 365; today included and still being counted), oldest first — the USD volume and the swaps by the token's position in the pair (`swapsAsToken0` / `swapsAsToken
  • get_token_holders · The largest current holders of a token, in descending balance order, with the balance in the token's smallest unit, plus `holderCount` — how many addresses hold a positive balance now — the same balances get_entity_token_balance answers. Cu
  • get_token_lending_markets · The lending markets where a token is listed, one per market — its roles there (`supply`, `borrow`, `collateral`), the amounts supplied and borrowed (raw units, and USD at the protocol's own oracle price), the supply and borrow rates as year
  • get_token_pools · The DEX pools that hold a token, newest created first — each with its protocol and version, fee tier where recorded (absent does not mean no fee), approximate creation block, its tokens (address, declared symbol and decimals, role, weight w
  • get_token_price · The USD price of a token for one hour — the newest priced hour by default, or the newest at or before `timestamp` (Unix seconds) or the time of `block` (one or the other): `priceUsd`, the hour it is for (`hour`), what it is (`priceSource`:
  • get_token_price_history · A token's USD price for every priced hour of a window (`from` to `to`, Unix seconds; the last 7 days by default, at most 90 days), oldest first — each with `priceUsd`, what it is (`priceSource`), whether it was carried over from an earlier
  • get_token_stats · How many token contracts, transfer events and holder positions (one address holding one token; not distinct addresses) the chain counts, in total and per standard (ERC-20, ERC-721, ERC-1155, ERC-777, ERC-4626). Use it for the size of the ch
  • get_token_transfers · The transfer events of one token contract, newest first — the parties, the raw amount (not scaled by decimals) or token id, the event kind, and the transaction that emitted it with who sent that transaction, which on a router or a batch dis
  • get_top_dex_tokens · The tokens with the most USD volume on the DEXes TraceFast decodes over the last `days` UTC days (1 to 30, default 7; today included and still being counted), most volume first — each with the symbol its contract declares (verbatim, not ver
  • get_top_pools · DEX pools ranked by USD volume over the last `days` UTC days (`by` `volume`, the default; `days` 1 to 30, default 7, today included and still being counted) or by the USD value they hold now (`by` `tvl`: only pools whose total TraceFast rat
  • get_trace_frames · 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 and the positio
  • get_transaction · 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, and its position (block and index). An unknown hash
  • get_transaction_account_changes · 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 w
  • get_transaction_events · 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
  • get_transaction_execution_profile · 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 D
  • get_transaction_failures · 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 s
  • get_transaction_flash_loans · 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 (`poolAd

The first 100 are shown.

What "online" means: the server answered an MCP connection at the time of the check. It is not a guarantee of security, quality or continuous uptime. How we test: we open an MCP session and ask for the tool list, as an AI assistant would. We never run a tool and never send a key. Checked every few days. Method

Is this your server? Monitoring Pro: a check every 30 minutes and an email within the hour when it stops answering. Launch offer: $39.99 once, for life.

Facts & evidence

Each fact shows where it was seen and when.
FactValueEvidenceSourceLast confirmed
Version0.2.0+acd465fbDECLAREDSRC-001 Official MCP Registry3h ago
Hosted endpointhttps://tracefast.xyz/mcpDECLAREDSRC-001 Official MCP Registry3h ago
Local install (package)noDECLAREDSRC-001 Official MCP Registry3h ago
Remote access (hosted)yesDECLAREDSRC-001 Official MCP Registry3h ago
Websitehttps://tracefast.xyzDECLAREDSRC-001 Official MCP Registry3h ago
Registry statusactiveDECLAREDSRC-001 Official MCP Registry3h ago
MCP serveryesDECLAREDSRC-001 Official MCP Registry3h ago

Change history

  • VERSION17 Nov 2026
    0.1.0+e9df2df8 → 0.2.0+acd465fb
  • NEW14 Nov 2026
    first seen in the index

Is this page accurate?

Flag it and our robot re-checks the official source. Reports never change a score.

Do you run TraceFast? Know when it stops answering

For publishers · optional

Its hosted endpoint can be monitored. Monitoring Pro connects every 30 minutes like an AI assistant, emails you within the hour when it stops answering, keeps a 90-day availability history and adds your answer rate to your badge.

Monitor TraceFastLaunch offer $39.99 once, for life instead of $9.99/month · All plans

Monitoring never changes a score or a rank.

Are you the publisher of TraceFast?

Free · show your listing

An independent listing builds trust with your buyers. Announce it, and add the badge to your website or README.

Announce it on LinkedIn
Listed on Electra IndexListed on Electra Index
<a href="https://electraindex.com/mcp/tracefast?utm_source=badge&utm_medium=share&utm_campaign=listing"><img src="https://electraindex.com/api/badge/tracefast/card" width="260" height="72" alt="Listed on Electra Index"></a>

Questions about TraceFast

How do I connect TraceFast?

Use the hosted endpoint https://tracefast.xyz/mcp in your assistant's MCP settings. The exact settings are in "How to connect" above, as declared in the Official MCP Registry.

What tools does TraceFast offer?

When Electra Index connected on 17 Nov 2026, it listed 109 tools: get_blacklist_events, get_blacklist_feed, get_blacklist_issuers, get_blacklist_status, get_blacklisted_addresses, get_blobs_daily, get_block, get_block_addresses and more. The full list is in "Live check" above.

Is TraceFast online?

Yes. Its hosted endpoint answered an MCP connection from Electra Index 3h ago.