Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "xytara-mcp-executor": {
      "type": "http",
      "url": "https://xytara-mcp-executor.onrender.com/mcp"
    }
  }
}

claude mcp add --transport http xytara-mcp-executor https://xytara-mcp-executor.onrender.com/mcp

[mcp_servers.xytara-mcp-executor]
url = "https://xytara-mcp-executor.onrender.com/mcp"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xytara-mcp-executor": {
      "type": "remote",
      "url": "https://xytara-mcp-executor.onrender.com/mcp",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "xytara-mcp-executor": {
      "type": "http",
      "url": "https://xytara-mcp-executor.onrender.com/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=xytara-mcp-executor&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8veHl0YXJhLW1jcC1leGVjdXRvci5vbnJlbmRlci5jb20vbWNwIn0%3D"
}

{
  "servers": {
    "xytara-mcp-executor": {
      "type": "http",
      "url": "https://xytara-mcp-executor.onrender.com/mcp"
    }
  }
}

{
  "mcpServers": {
    "xytara-mcp-executor": {
      "httpUrl": "https://xytara-mcp-executor.onrender.com/mcp"
    }
  }
}

extensions:
  "xytara-mcp-executor":
    enabled: true
    name: "xytara-mcp-executor"
    type: streamable_http
    uri: "https://xytara-mcp-executor.onrender.com/mcp"
    timeout: 300

Quality 75 / 100good

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene100 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations17 of 17 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
pass
tools.token_costabout 3,956 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability25 · weight 15

warn
stability.changes31 tool changes in 30 days
fail
stability.rug_pull17 tools kept their name but changed most of their description in 30 days; review before trusting them

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

17 tools, about 3,956 tokens to load them all · tool set 4eb66210b878 · tools last changed 2026-10-20 · checked 2026-10-20 18:38 UTC

Tool changes

2026-10-20tx.statuschangeddescription
before
Looks up a transaction by hash on Base mainnet (default) or Base Sepolia: success/failed/pending, block, confirmations, from, to, value and gas. network accepts eip155:8453, base, 8453, eip155:84532, base-sepolia, 84532. A hash unknown to the chain is reported clearly as found:false. ~5 s budget; RPC unavailable fails (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
after · 61% of words in common
Looks up a transaction by hash on Base mainnet (default) or Base Sepolia: success/failed/pending, block, confirmations, from, to, value and gas. network accepts eip155:8453, base, 8453, eip155:84532, base-sepolia, 84532. A hash unknown to the chain is reported clearly as found:false. ~5 s budget; RPC unavailable fails (not charged). Price: $0.02 USDC per call on Base mainnet ($0.002 on Base Sepolia), paid with x402 or 6 credits with a spend key; failed calls are not charged. The result carries a signed attestation (naxytra-attestation/1, in result._meta["naxytra.com/attestation"]) of what was observed on-chain — verified true or false — that you can hand to a third party; keys at /.well-known/delivery-receipt-keys.
2026-10-20x402.verify-receiptchangeddescription
before
Decodes an x402 PAYMENT-RESPONSE receipt and checks Base / Base Sepolia: settlement_confirmed is true only if the tx succeeded and its logs contain a USDC Transfer to the expected payTo (pay_to, else this server's) for the expected amount (amount, else this server's price) from the stated payer. RPC unavailable, unknown network or a receipt without a tx fails (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
after · 62% of words in common
Decodes an x402 PAYMENT-RESPONSE receipt and checks Base / Base Sepolia: settlement_confirmed is true only if the tx succeeded and its logs contain a USDC Transfer to the expected payTo (pay_to, else this server's) for the expected amount (amount, else this server's price) from the stated payer. RPC unavailable, unknown network or a receipt without a tx fails (not charged). Price: $0.02 USDC per call on Base mainnet ($0.002 on Base Sepolia), paid with x402 or 6 credits with a spend key; failed calls are not charged. The result carries a signed attestation (naxytra-attestation/1, in result._meta["naxytra.com/attestation"]) of what was observed on-chain — verified true or false — that you can hand to a third party; keys at /.well-known/delivery-receipt-keys.
2026-10-19eip712.hashchangedtitle, description, input schema, annotationsmeaning changed
before
Compute the EIP-712 typed-data digest plus domain separator, struct hash, and encodeType from domain, types, primaryType, and message. Matches what wallets sign, including the x402 USDC transferWithAuthorization authorization.
after · 39% of words in common
Computes the EIP-712 digest, domain separator, struct hash and encodeType from domain, types, primaryType and message (what wallets sign, including the x402 USDC TransferWithAuthorization). Every field is type-checked; a missing field fails with missing_field:<path> (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19merkle.verifychangedtitle, description, input schema, annotationsmeaning changed
before
Verify a Merkle proof with keccak256 (OpenZeppelin sorted-pair by default): checks a leaf against a root given the proof, and returns the computed root.
after · 18% of words in common
Verifies a keccak256 Merkle proof. leaf, root and every proof entry must be 0x 32-byte hashes (hash_leaf:true keccak-hashes a raw leaf first). sorted:true (default) is OpenZeppelin MerkleProof (sorted pairs); sorted:false needs leaf_index or positions to order each pair. Up to 256 proof entries. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19abi.decodechangedtitle, description, input schema, annotationsmeaning changed
before
ABI-decode hex data into values given the Solidity types.
after · 9% of words in common
Decodes ABI-encoded hex for the given types (same type support as abi.encode). Strict: every length and offset is bounded by the data present, dirty padding bits and trailing bytes are rejected, and calldata with a 4-byte selector is flagged. Integers are returned as decimal strings, addresses checksummed. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19abi.encodechangedtitle, description, input schema, annotationsmeaning changed
before
ABI-encode values for EVM calldata or return data. Supports elementary types (address, bool, uint/int, bytesN), dynamic bytes/string, and arrays of static types.
after · 15% of words in common
Solidity ABI encoding (like abi.encode): address, bool, uint8-256, int8-256, bytes1-32, bytes, string, dynamic T[] and fixed T[k] arrays, and tuples written (uint256,address), nested to any depth. Strict: exact 20-byte (checksum-valid) addresses, range-checked integers, exact bytesN length, JSON true/false for bool, JSON arrays for arrays and tuples. Integers as decimal strings (or safe JSON numbers). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19tx.statuschangedtitle, description, input schema, annotationsmeaning changed
before
Look up an EVM transaction's on-chain status and details by hash on Base or Base Sepolia: success/failed, block, from, to, value, and gas.
after · 30% of words in common
Looks up a transaction by hash on Base mainnet (default) or Base Sepolia: success/failed/pending, block, confirmations, from, to, value and gas. network accepts eip155:8453, base, 8453, eip155:84532, base-sepolia, 84532. A hash unknown to the chain is reported clearly as found:false. ~5 s budget; RPC unavailable fails (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19x402.verify-receiptchangedtitle, description, input schema, annotationsmeaning changed
before
Decode an x402 PAYMENT-RESPONSE settlement receipt and confirm the settlement transaction on-chain (Base / Base Sepolia), returning success, tx, payer, and block.
after · 19% of words in common
Decodes an x402 PAYMENT-RESPONSE receipt and checks Base / Base Sepolia: settlement_confirmed is true only if the tx succeeded and its logs contain a USDC Transfer to the expected payTo (pay_to, else this server's) for the expected amount (amount, else this server's price) from the stated payer. RPC unavailable, unknown network or a receipt without a tx fails (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19address.validatechangedtitle, description, input schema, annotationsmeaning changed
before
Validate an EVM address and compute its EIP-55 checksum; reports format validity, checksum correctness, and whether it is the zero address.
after · 20% of words in common
Checks an EVM address: format (0x + 40 hex), EIP-55 checksum (for mixed-case input), zero address, and returns the checksummed form. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
2026-10-19keccak256changedtitle, description, input schema, annotationsmeaning changed
before
Compute the Ethereum keccak256 hash of UTF-8 or hex input; returns the 32-byte digest and the 4-byte function/event selector.
after · 27% of words in common
Ethereum keccak256 of the input: returns the 32-byte digest and the 4-byte selector. encoding auto (default) hashes 0x-hex input as bytes and anything else as UTF-8 text; force utf8 or hex explicitly. The empty string is allowed. Up to 250000 bytes. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 82 / 100

no-repository

provenance55

liveness98

freshness100

hygiene80

+dns-namespace +website +reachable +uptime-95% +updated-0d-ago -no-repository

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://xytara-mcp-executor.onrender.com/mcp` streamable-http	none	yes	95%	328 ms	2025-11-25	2026-10-20

Tools (17)

`abi.decode`read-only	Decodes ABI-encoded hex for the given types (same type support as abi.encode). Strict: every length and offset is bounded by the data present, dirty padding bits and trailing bytes are rejected, and calldata with a 4-byte selector is flagged. Integers are returned as decimal strings, addresses checksummed. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`abi.encode`read-only	Solidity ABI encoding (like abi.encode): address, bool, uint8-256, int8-256, bytes1-32, bytes, string, dynamic T[] and fixed T[k] arrays, and tuples written (uint256,address), nested to any depth. Strict: exact 20-byte (checksum-valid) addresses, range-checked integers, exact bytesN length, JSON true/false for bool, JSON arrays for arrays and tuples. Integers as decimal strings (or safe JSON numbers). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`address.validate`read-only	Checks an EVM address: format (0x + 40 hex), EIP-55 checksum (for mixed-case input), zero address, and returns the checksummed form. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`catalog`read-only	Lists the enabled tools with titles, descriptions and the price. Same information as tools/list. Free: never requires payment.
`eip712.hash`read-only	Computes the EIP-712 digest, domain separator, struct hash and encodeType from domain, types, primaryType and message (what wallets sign, including the x402 USDC TransferWithAuthorization). Every field is type-checked; a missing field fails with missing_field:<path> (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`html.to-text`read-only	Converts HTML to readable plain text: drops scripts/styles/comments and all attribute text, keeps paragraph and list structure, separates table cells with " \| ", decodes numeric and common named entities, and returns the <title> separately. Input up to 250000 characters; single linear pass. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`json.validate`read-only	Validates a JSON payload (any JSON value, or JSON text as a string) against a JSON Schema and returns valid plus every error with its JSON Pointer path. Supported keywords: type, required, properties, additionalProperties, items/prefixItems, enum, const, minimum/maximum, exclusiveMinimum/exclusiveMaximum, multipleOf, minLength/maxLength, pattern, minItems/maxItems, uniqueItems, min/maxProperties, allOf. A schema using other keywords ($ref, anyOf, oneOf, not, if/then) is rejected (not charged) rather than half-checked. Without a schema only well-formedness is checked. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`keccak256`read-only	Ethereum keccak256 of the input: returns the 32-byte digest and the 4-byte selector. encoding auto (default) hashes 0x-hex input as bytes and anything else as UTF-8 text; force utf8 or hex explicitly. The empty string is allowed. Up to 250000 bytes. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`merkle.verify`read-only	Verifies a keccak256 Merkle proof. leaf, root and every proof entry must be 0x 32-byte hashes (hash_leaf:true keccak-hashes a raw leaf first). sorted:true (default) is OpenZeppelin MerkleProof (sorted pairs); sorted:false needs leaf_index or positions to order each pair. Up to 256 proof entries. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`reply.draft`read-only	Builds a structured reply to a message: greeting to the sender (name detected from the sign-off, or sender_name), acknowledgement, every question and request found in the message listed with an answer placeholder, deadlines noted, and a tone-matched sign-off. Deterministic template: it organizes the reply but does not invent the answers (placeholders in [brackets]). Input up to 20000 characters. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`summarize`read-only	Extractive summary: returns the first sentences of the text (default 3, up to 10) capped at max_chars (default 600, 50-2000), taken from the first 4000 characters. Deterministic; it does not paraphrase. `truncated` is true when the source was longer than the considered window. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`text.chunk`read-only	Splits text into chunks of at most max_chars (100-20000, default 2000) preferring paragraph, line, sentence and word boundaries, with optional overlap (up to half of max_chars). Sizes are UTF-16 code units; surrogate pairs (emoji) are never split. Input up to 250000 characters. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`text.extract`read-only	Extracts emails, URLs (trailing punctuation stripped), IPv4 addresses, EVM addresses, transaction hashes, @mentions, #hashtags, prices, ISO/slash dates and phone numbers (dates, IPs and plain numbers are not reported as phones). Input up to 200000 characters; linear-time. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`tx.status`read-only	Looks up a transaction by hash on Base mainnet (default) or Base Sepolia: success/failed/pending, block, confirmations, from, to, value and gas. network accepts eip155:8453, base, 8453, eip155:84532, base-sepolia, 84532. A hash unknown to the chain is reported clearly as found:false. ~5 s budget; RPC unavailable fails (not charged). Price: $0.02 USDC per call on Base mainnet ($0.002 on Base Sepolia), paid with x402 or 6 credits with a spend key; failed calls are not charged. The result carries a signed attestation (naxytra-attestation/1, in result._meta["naxytra.com/attestation"]) of what was observed on-chain — verified true or false — that you can hand to a third party; keys at /.well-known/delivery-receipt-keys.
`x402.decode`read-only	Decodes an x402 payment challenge (base64 PAYMENT-REQUIRED header, or the JSON; v2 `amount` and v1 `maxAmountRequired`) into networks, assets, human amounts and payTo. A challenge with no payment options fails (not charged). Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.
`x402.verify-receipt`read-only	Decodes an x402 PAYMENT-RESPONSE receipt and checks Base / Base Sepolia: settlement_confirmed is true only if the tx succeeded and its logs contain a USDC Transfer to the expected payTo (pay_to, else this server's) for the expected amount (amount, else this server's price) from the stated payer. RPC unavailable, unknown network or a receipt without a tx fails (not charged). Price: $0.02 USDC per call on Base mainnet ($0.002 on Base Sepolia), paid with x402 or 6 credits with a spend key; failed calls are not charged. The result carries a signed attestation (naxytra-attestation/1, in result._meta["naxytra.com/attestation"]) of what was observed on-chain — verified true or false — that you can hand to a third party; keys at /.well-known/delivery-receipt-keys.
`zones.lookup`read-only	Live DNS lookup of A, AAAA, CNAME, MX, NS and TXT records for a domain (a URL is accepted; its hostname is used; IDNs are punycoded). 2 s per query, ~5 s total. Per-record errors are reported in record_errors; if no record resolves at all the call fails and is not charged. Price: $0.01 USDC per call on Base mainnet ($0.001 on Base Sepolia), paid with x402; failed calls are not charged.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "com.naxytra/xytara-mcp-executor",
  "title": "xytara MCP Executor",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://xytara-mcp-executor.onrender.com/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "3.3.0",
  "websiteUrl": "https://www.naxytra.com/agents",
  "description": "Pay-per-call MCP tools and signed on-chain attestations: 20 free/day, then $0.01+ via x402 or a key."
}