CyberWareX MCP Servers
OfficialProvides EVM chain data tools for Ethereum, including wallet, token, price, gas, transaction, and ENS lookups.
Provides EVM chain data tools for Optimism, including wallet, token, price, gas, and transaction lookups.
Provides EVM chain data tools for Polygon, including wallet, token, price, gas, and transaction lookups.
CyberWareX MCP Servers
MCP (Model Context Protocol) servers for the CyberWareX suite — pay-per-call APIs built for AI agents. Every backing API is live, speaks x402 (HTTP 402 → pay USDC on Base → result), and needs no account and no API key: the first paid call is the entire onboarding.
Server | Tools | What it does | Price |
| Live web pages as LLM-ready markdown, CSS extraction, screenshots, PDFs | $0.005–$0.01 | |
| "Is this token safe to trade?" — live buy/sell simulation, contract powers, A–F grade with evidence (Base + BSC). 3 free calls/day with header | $0.02–$0.06 | |
| EVM data across Base, Ethereum, Arbitrum, Optimism, Polygon — no RPC keys, no node | $0.002–$0.004 | |
| Voice messages → text, per 10-second block | $0.015 | |
| Pre-sign safety for wallet/trading agents: simulate a tx before signing, decode EIP-712/personal_sign requests (drainer flags), sanctions + scam-ledger address screening, verified ABI, URL phishing score. 6 chains. 3 free calls/day per service | $0.002–$0.01 |
Install
pip install mcp requestsEach server is a single self-contained file speaking MCP over stdio:
python web-access/mcp_server.pyClaude Desktop / Claude Code config
{
"mcpServers": {
"cyberwarex-web": { "command": "python", "args": ["/path/to/cyberwarex-mcp/web-access/mcp_server.py"] },
"cyberwarex-oracle": { "command": "python", "args": ["/path/to/cyberwarex-mcp/defi-oracle/mcp_server.py"] },
"cyberwarex-chain": { "command": "python", "args": ["/path/to/cyberwarex-mcp/chain-data/mcp_server.py"] },
"cyberwarex-voice": { "command": "python", "args": ["/path/to/cyberwarex-mcp/voice-stt/mcp_server.py"] }
}
}Related MCP server: hyperd-mcp
How payment works
These servers never hold keys and never pay. An unpaid tool call returns the x402
invoice (x402_payment_required: true with the full accepts block) so the calling
agent's x402 client can sign the gasless EIP-3009 USDC authorization and retry —
either through the agent's own payment stack, or by setting the *_X_PAYMENT env var
with a pre-signed payment header.
Machine-readable catalog of everything: https://cyberwarex.com/.well-known/x402 (LLM-readable summary at /llms.txt).
Configuration (env vars)
Server | Base URL override | Payment header | Timeout |
web-access |
|
|
|
defi-oracle |
|
|
|
chain-data |
|
|
|
voice-stt |
|
|
|
Defaults point at the live public services — they work out of the box.
License
MIT — see LICENSE. Contact: x402@cyberwarex.com
Available Tools
3 toolscontract_riskA
Inspect what the team behind a token contract is able to do to holders, without running a trade simulation. Reports verified-source status, whether the contract is an upgradeable proxy and who its admin is, whether ownership is renounced, and which dangerous powers exist (mint, pause, blacklist, and mutable fees). Use it when you want the governance and rug-vector picture rather than the tradeability verdict. Returns JSON with each power as a boolean plus the resolved owner and admin addresses. Read-only. Paid per call in USDC on Base via x402.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Which chain the token lives on: 'base' for Base mainnet (the default) or 'bsc' for BNB Smart Chain. It must match the network the address is deployed on. | base |
| address | Yes | The ERC-20 token contract address to evaluate: a 42-character hex string starting with 0x (for example 0x4200000000000000000000000000000000000006). This is the token you are about to buy, approve, or receive. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It explicitly states 'Read-only' and 'Paid per call in USDC on Base via x402,' and notes it does not run a trade simulation. This covers safety and cost. It also describes the return format (JSON with booleans plus owner/admin addresses). It does not disclose error behavior or rate limits, but for a read-only inspection tool this is sufficient, and nothing contradicts annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is multi-sentence but each sentence contributes: purpose, list of checks, usage guidance, return format, and payment/read-only note. It front-loads the primary action and scope, then adds context. It is not overly verbose; every clause earns its place, though it could be tightened slightly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description must convey what the tool returns; it does ('Returns JSON with each power as a boolean plus the resolved owner and admin addresses'). It also covers payment and read-only nature. For a 2-parameter tool with no output schema, this is adequately complete, though it omits details like error handling or default chain nuances, which are minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% – both 'chain' and 'address' have detailed descriptions including defaults, formats, and examples. The description adds minimal parameter-level value beyond the schema, such as clarifying the address is the token you are about to buy/approve/receive, which is usage context rather than semantic detail. Per the baseline, a 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Inspect') and resource ('what the team behind a token contract is able to do to holders') and enumerates concrete checks (verified-source, proxy/admin, ownership renounced, dangerous powers). It explicitly contrasts with tradeability, distinguishing it from the siblings token_safety and honeypot_check without needing to open their schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives a clear when-to-use directive: 'Use it when you want the governance and rug-vector picture rather than the tradeability verdict.' This implies when not to use it (when you need tradeability), and the sibling names are visible in context. However, it does not name alternatives explicitly or list exclusions beyond the tradeability distinction, so a slight gap remains.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
honeypot_checkA
Answer one focused question: can this token actually be sold after it is bought? Executes a real buy-then-sell round trip as a simulated transaction on Base or BSC. Use it when you only need the honeypot yes-or-no, not the full safety report. Returns JSON with: is_honeypot (boolean), buy_success (boolean), sell_success (boolean), and round_trip_loss_percent (the tax or slippage lost across the round trip). Read-only: no wallet needed. Paid per call in USDC on Base via x402.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Which chain the token lives on: 'base' for Base mainnet (the default) or 'bsc' for BNB Smart Chain. It must match the network the address is deployed on. | base |
| address | Yes | The ERC-20 token contract address to evaluate: a 42-character hex string starting with 0x (for example 0x4200000000000000000000000000000000000006). This is the token you are about to buy, approve, or receive. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that it executes a real transaction as a simulation ('simulated transaction') and is read-only ('Read-only: no wallet needed'), which is critical given no annotations. It also details the output fields (is_honeypot, buy_success, sell_success, round_trip_loss_percent) and the pricing model (paid per call in USDC on Base via x402), going beyond annotations to provide complete behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: it starts with the core purpose, then details the method and output. Every sentence adds value—the use case, the return format, the read-only and payment info. No fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, no output schema, no annotations), the description covers all needed aspects: what it does, how it works, what to expect back, and usage constraints. It is complete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are already described in the schema. The description does not add extra detail beyond the schema, but it references the address as 'the token you are about to buy, approve, or receive', which provides slight context. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: answering whether a token can be sold after being bought, using a simulated buy-sell round trip. It names the specific resource (token address), the action (real buy-then-sell round trip), and the supported chains (Base or BSC). This distinguishes it from siblings like token_safety and contract_risk, which likely provide broader analyses.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'when you only need the honeypot yes-or-no, not the full safety report.' This implies alternatives (full safety report) and provides a clear exclusion criterion. It also notes the paid nature and read-only status, setting expectations for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
token_safetyA
Decide whether an ERC-20 token is safe to trade before committing funds. Runs a live buy-then-sell simulation (Aerodrome and Uniswap V3) plus contract-power and ownership analysis and a GoPlus and honeypot.is cross-check, then returns a single verdict. Use it when an agent is about to swap into, approve, or accept a token it has not vetted. Returns JSON with: grade (A to F), risk_score (0-100), is_honeypot (boolean), tradeable (boolean), and a flags array where each flag carries on-chain evidence. Read-only: no wallet, key, or signature needed; a cold simulation can take a few seconds. Paid per call in USDC on Base via x402.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Which chain the token lives on: 'base' for Base mainnet (the default) or 'bsc' for BNB Smart Chain. It must match the network the address is deployed on. | base |
| address | Yes | The ERC-20 token contract address to evaluate: a 42-character hex string starting with 0x (for example 0x4200000000000000000000000000000000000006). This is the token you are about to buy, approve, or receive. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: it is read-only ('no wallet, key, or signature needed'), mentions latency ('a cold simulation can take a few seconds'), and discloses cost ('Paid per call in USDC on Base via x402'). It also describes the output structure (JSON with grade, risk_score, is_honeypot, tradeable, flags). This goes beyond basic and covers operational concerns an agent must know before invoking.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the purpose. It covers purpose, methodology, usage trigger, output format, and operational notes in a compact manner. While it is somewhat long, each sentence provides necessary information. It could be slightly tightened by removing redundant phrases like 'the token you are about to buy' which is already in the schema, but overall it is appropriate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with this complexity (simulation, multiple analyses, output schema absent), the description is quite complete. It describes what it does, what it returns, and how it behaves operationally. It does not explicitly contrast with siblings, but the purpose clarity already achieves that. The only minor gap is not mentioning that it only supports the two chains in the schema, but that is in the schema. Overall, an agent has enough to decide when and how to call it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are well-documented in the input schema. The description does not add extra semantic detail beyond what the schema provides (e.g., it does not elaborate on address format or chain selection). Since the schema already carries the full meaning, a score of 3 (baseline) is appropriate; the description adds no additional value for parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific, actionable purpose: 'Decide whether an ERC-20 token is safe to trade before committing funds.' It names the resource (ERC-20 token) and the exact decision (safe to trade). It also differentiates from siblings by listing its comprehensive methodology (live simulation, contract analysis, GoPlus/honeypot cross-check) which clearly sets it apart from narrower tools like honeypot_check and contract_risk.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Use it when an agent is about to swap into, approve, or accept a token it has not vetted.' This is clear and actionable. It does not explicitly mention alternatives or when not to use, but the context is sufficient because the tool is the comprehensive safety check, and siblings are more specific. A minor omission is not explicitly saying 'for a full safety verdict, use this, not the narrower checks'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v1.0.0- First observed
contract_risk - First observed
honeypot_check - First observed
token_safety
TDQS
Scored across 3 tools
token_safety is the full-report umbrella and naturally overlaps with both honeypot_check and contract_risk, but the focused tools have clearly distinct single-purpose roles: sellability only vs. contract governance only. Descriptions make the separation actionable, though an agent might overuse token_safety when a lighter check would suffice.
All three tool names use lowercase snake_case and follow a consistent target_aspect pattern: token_safety, honeypot_check, contract_risk. There is no mixed casing or style drift, and each name clearly reflects its focused purpose.
Three tools is a well-scoped size for a token-security domain: one comprehensive vetting tool plus two dedicated focused checks. Each tool earns its place and there is no bloat or trivial filler.
The surface covers the core token-vetting workflow: full tradeability verdict, isolated honeypot detection, and contract-power/ownership risk. Minor gaps exist such as explicit liquidity-lock or approval-specific checks, but they are largely covered indirectly through the GoPlus and contract analysis layers.
Maintenance
Related MCP Connectors
30 pay-per-call APIs for AI agents: compliance, trade, safety, web, data. USDC on Base via x402.
Pay-per-call data APIs for AI agents. USDC on Base via x402. 33 tools, no signup.
x402 paid APIs for AI agents on Base. Blockchain, wallet, DEX, crypto, web search.
Pay-per-call (x402/USDC-Base) web + crypto data tools for AI agents: audit, extract, crypto, DeFi.
Related MCP Servers
- FlicenseNot gradedqualityFmaintenance20 pay-per-call utility tools for AI agents via x402 USDC micropayments on Base. Screenshots, OCR, PDF, web scraping, weather, forex rates, crypto/stock prices, DNS, geocoding, translation, and more. $0.001–$0.008 per call. No API keys, no signup.1-

hyperd-mcpofficial
AlicenseAqualityDmaintenancePre-trade DeFi intelligence for AI agents. 20 paid x402 endpoints, USDC on Base.2341 npm1MIT- AlicenseBqualityAmaintenancePay-per-call AI agent APIs on Base via x402. Multiple tools across patents, law, AI, geo, weather, crypto, and more. Always growing.2018MIT

AfaAgent x402 API Suiteofficial
FlicenseNot gradedqualityCmaintenance43 x402-enabled API tools — DeFi, wallet security, AI/ML, developer tools, SEO. Pay-per-call USDC on Base via x402 protocol.-