Sub Killer MCP Server
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Sub Killer MCP ServerScan my wallet for risky approvals"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Sub Killer MCP Server
MCP server for Dead Subscription Killer — scan wallets, detect crypto subscriptions, manage approvals on Monad.
The first MCP server for blockchain subscription management.
What Is This?
An MCP (Model Context Protocol) server that lets AI agents (Claude, Cursor, Windsurf, etc.) scan wallets for forgotten token approvals and subscriptions on the Monad blockchain.
Use Cases
"Scan my wallet for risky approvals" — agent calls
scan_wallet"What is this spender address?" — agent calls
identify_spender"How much would I save on Monad vs Ethereum?" — agent calls
estimate_gas_savings"Do a security audit of my wallet" — agent uses
security_auditprompt
Related MCP server: Monad MCP Tutorial
Tools
Tool | Description |
| Scan a wallet for active token approvals |
| Identify what a spender address is (protocol, category, risk) |
| List all known DeFi protocols with risk levels |
| Check allowance for specific token/spender |
| Get user stats from SubscriptionKiller contract |
| Get subscriptions from contract |
| Compare gas costs Monad vs Ethereum |
| Get Monad network details |
Resources
Resource | Description |
| Full known protocols database |
| Protocol categories |
| Monad testnet config |
| Monad mainnet config |
Prompts
Prompt | Description |
| Comprehensive wallet analysis |
| Security-focused approval audit |
| Gas cost comparison Monad vs Ethereum |
Setup
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"sub-killer": {
"command": "node",
"args": ["/path/to/sub-killer-mcp/src/index.js"]
}
}
}Cursor
Add to .cursor/mcp.json:
{
"mcpServers": {
"sub-killer": {
"command": "node",
"args": ["/path/to/sub-killer-mcp/src/index.js"]
}
}
}With npx (after publishing)
{
"mcpServers": {
"sub-killer": {
"command": "npx",
"args": ["-y", "sub-killer-mcp"]
}
}
}Install & Run
npm install
node src/index.jsTest
node src/test.jsKnown Protocols Database
Includes 40+ known DeFi protocols across categories:
DEX: Uniswap, SushiSwap, PancakeSwap, 1inch
Lending: Aave, Compound
Staking: Lido, Rocket Pool, Coinbase
NFT: OpenSea, Blur
Derivatives: dYdX, GMX
Bridges: Base, Optimism, Arbitrum
Architecture
sub-killer-mcp/
├── src/
│ ├── index.js # MCP server entry point
│ ├── test.js # Test suite
│ ├── tools/
│ │ └── index.js # Tool definitions & handlers
│ ├── lib/
│ │ └── scanner.js # Blockchain scanner (viem)
│ └── data/
│ └── protocols.js # Known protocols DB
├── package.json
└── README.mdWhy Monad?
Metric | Ethereum | Monad |
Gas per tx | $20-50 | $0.001 |
Finality | 12 min | <1s |
TPS | 15 | 10,000 |
Batch-cancelling 10 subscriptions costs ~$300 on Ethereum. On Monad: $0.01.
License
MIT
Available Tools
8 toolscheck_allowanceA
Check the current allowance a wallet has granted to a specific spender for a specific token.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | The wallet address (owner) | |
| token | Yes | The token contract address | |
| network | No | testnet | |
| spender | Yes | The spender contract address |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It accurately describes a read-only operation but does not disclose any behavioral traits beyond that, such as whether it returns a value or requires specific permissions. It is not misleading but lacks depth.
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 a single concise sentence that clearly communicates the tool's purpose without any fluff or unnecessary words.
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 simple read tool with 4 parameters and no output schema, the description is adequate but incomplete. It does not mention the return value (likely the allowance amount) or any network-specific behavior, which would be helpful for an agent.
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 75% (3 of 4 parameters have descriptions), so baseline is 3. The description adds no additional semantics beyond what the schema already provides for owner, token, and spender. The network parameter has an enum and default but is not elaborated in the description.
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 function: checking an allowance from a wallet to a spender for a specific token. It uses a specific verb and resource, distinguishing it from sibling tools like scan_wallet or identify_spender.
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?
The description implies when to use the tool (to check an allowance) but does not provide explicit guidance on when not to use it or compare it to alternatives. There is no mention of prerequisites or context like network selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
estimate_gas_savingsB
Estimate how much gas money a user saves by using Monad instead of Ethereum for subscription management.
| Name | Required | Description | Default |
|---|---|---|---|
| num_subscriptions | Yes | Number of subscriptions to cancel |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only states purpose without disclosing behavioral traits like read-only nature, dependencies, or reliability.
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?
Single concise sentence, front-loaded with purpose. No wasted words.
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?
Lacks output description (no output schema). For an estimation tool, return format or units should be mentioned. Incomplete for 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 has 100% coverage; parameter description matches tool's use. Description adds no new semantic meaning beyond what schema provides.
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 it estimates gas savings, with a specific context (Monad vs Ethereum for subscription management). Distinguishes from sibling tools which cover different domains.
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?
Implies usage for subscription management savings analysis, but no explicit guidance on when to use or when to avoid compared to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_contract_statsA
Get user statistics from the SubscriptionKiller smart contract (how many scanned, cancelled, saved). Contract address is optional if deployed contracts are configured.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | The wallet address to check | |
| network | No | testnet | |
| contract_address | No | The SubscriptionKiller contract address (optional, uses deployed default) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries full burden. It discloses the return metrics and that contract_address is optional, but omits potential side effects, permissions, or format of output. Adequate but not thorough.
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?
Single sentence that efficiently conveys purpose and one key usage note. No redundant information.
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 no output schema, description hints at returned counts. However, missing details on error cases, network defaults, and output format. Mostly sufficient for a simple stats tool.
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 67%. Description adds value for contract_address (optional when configured), but adds no info on address or network parameters beyond schema defaults. Baseline adequate.
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 retrieves user statistics from the SubscriptionKiller smart contract, specifying the metrics (scanned, cancelled, saved). It is distinct from siblings like check_allowance or scan_wallet.
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?
No guidance on when to use this tool versus siblings. Only a note that contract_address is optional, but lacks context for selection criteria or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_contract_subscriptionsB
Get all subscriptions registered in the SubscriptionKiller smart contract for a user. Contract address is optional if deployed contracts are configured.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | The wallet address to check | |
| network | No | testnet | |
| contract_address | No | The SubscriptionKiller contract address (optional, uses deployed default) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of behavioral disclosure. It only says 'Get,' implying a read operation, but lacks explicit statements about read-only, side effects, permissions, or rate limits. This is insufficient for transparency.
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 two sentences with no redundant information. It front-loads the main purpose and then adds a conditional note. Every sentence earns its place.
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?
With no output schema, the description should hint at the return structure (e.g., list of subscriptions). It does not mention return format, edge cases, or error conditions. For a three-parameter tool, it is somewhat incomplete.
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 67% (two out of three parameters have descriptions). The description adds context for the 'contract_address' parameter ('optional if deployed contracts are configured'), which clarifies its usage beyond the schema. However, it adds little for 'address' and nothing for 'network.' Overall, it adds some value but does not fully compensate for the missing schema descriptions.
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 verb 'Get' and the resource 'subscriptions registered in the SubscriptionKiller smart contract for a user.' It also specifies that the contract address is optional if defaults are configured, distinguishing it from siblings like 'scan_wallet' or 'check_allowance' which have different purposes.
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?
The description provides minimal guidance: 'Contract address is optional if deployed contracts are configured.' It does not explicitly state when to use this tool versus alternatives (e.g., 'scan_wallet'), nor does it provide conditions or prerequisites for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_known_protocolsB
Get the list of known DeFi protocols and their risk categories. Use this to identify what a spender address is.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Filter by category (DEX, Lending, Staking, NFT, etc.) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so description must carry full burden. It indicates a read operation but lacks details on permissions, rate limits, response format, or whether data is cached. Minimal 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?
Two concise sentences with no redundancy. Front-loaded with purpose, followed by usage hint.
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?
No output schema, so description should describe return structure. Only mentions 'list of protocols and risk categories' but lacks details on fields, completeness, or how it integrates with siblings. Adequate but incomplete.
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% with parameter 'category' having a clear description. Tool description adds no extra value beyond the schema, justifying baseline score.
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?
Description clearly states the tool retrieves a list of DeFi protocols and risk categories, using specific verb 'Get'. It hints at a use case ('identify what a spender address is') but does not explicitly distinguish from sibling tools like identify_spender or check_allowance.
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?
Implies usage for identifying spender addresses, but no guidance on when not to use or alternatives. Sibling tool list exists but no differentiation provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_network_infoA
Get information about the Monad network (RPC, chain ID, gas costs).
| Name | Required | Description | Default |
|---|---|---|---|
| network | No | testnet |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It explicitly states it retrieves information, making the read-only nature clear. No mention of rate limits or auth, but acceptable for a simple info tool.
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?
Single sentence, no wasted words. Could potentially add more structure, but it is efficient and front-loaded with the key action.
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 simple tool with one optional parameter and no output schema, the description is fairly complete. It covers the purpose and kind of data returned, though output format is omitted.
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 0%. The description does not mention the single parameter 'network' (enum: testnet/mainnet). Some guidance would help, though the enum is self-explanatory.
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 retrieves network information (RPC, chain ID, gas costs). It is distinct from sibling tools like scan_wallet or get_contract_stats, which target different resources.
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?
The description implies usage when network details are needed. It does not provide explicit when-not-to-use or alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
identify_spenderA
Identify what a spender address is (protocol name, category, risk level). Useful when scan_wallet returns unknown spenders.
| Name | Required | Description | Default |
|---|---|---|---|
| spender_address | Yes | The spender address to identify |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It does not mention whether the tool is read-only, requires authentication, has rate limits, or any side effects. This is insufficient for an agent to assess safety.
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 two sentences, front-loading the purpose and then usage context. It is concise with no wasted words, though an example could be added without harming conciseness.
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 simple one-parameter lookup tool with no output schema, the description covers purpose, outputs, and usage context. It adequately informs an agent, but could be improved by mentioning potential return format or edge cases.
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% with a basic description for spender_address. The tool description adds no further meaning beyond the schema, so 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 verb 'identify' and the resource 'spender address', listing the outputs (protocol name, category, risk level). It distinguishes itself from sibling scan_wallet by explicitly mentioning its use case.
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?
The description provides clear context: 'Useful when scan_wallet returns unknown spenders.' This tells when to use the tool, though it doesn't explicitly exclude other scenarios or mention alternatives like get_known_protocols.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_walletB
Scan a wallet address for active token approvals, recurring payments, and subscription patterns on Monad. Returns a list of detected approvals with risk levels.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | The wallet address to scan (0x...) | |
| network | No | Monad network to scan | testnet |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It discloses the tool scans and returns data, implying a read operation, but does not explicitly confirm it is non-destructive or discuss authentication needs or rate limits.
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?
Two sentences: first states purpose, second states return. Concise and front-loaded, but the structure could be slightly improved by separating the list of scanned items from the return type.
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?
Missing output schema. Description mentions scanning for payments and subscriptions but only says returns approvals with risk levels, creating a gap. No details on pagination, result limits, or network differences.
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% describing both parameters (address and network). The description does not add extra meaning beyond the schema, so baseline score of 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 scans a wallet for token approvals, payments, and subscriptions on Monad, and returns a list with risk levels. It is specific but does not explicitly distinguish from sibling tools like check_allowance or get_contract_subscriptions.
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?
No guidance on when to use this tool versus alternatives like check_allowance or get_contract_subscriptions. No exclusions or prerequisites are mentioned.
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. Dates show when Glama detected each change.
8 tool updates
v1.0.0- First observed
check_allowance - First observed
estimate_gas_savings - First observed
get_contract_stats - First observed
get_contract_subscriptions - First observed
get_known_protocols - First observed
get_network_info - First observed
identify_spender - First observed
scan_wallet
TDQS
Tool purposes are mostly distinct, with minor overlap between scan_wallet (detecting approvals and subscriptions) and get_contract_subscriptions (listing subscriptions from a contract). Identify_spender and get_known_protocols are complementary but serve different immediate needs.
All tool names follow a consistent verb_noun pattern in snake_case, e.g., scan_wallet, identify_spender, estimate_gas_savings. No mixed conventions or ambiguous verbs.
With 8 tools, the server is well-scoped for its purpose of scanning wallet subscriptions and allowances on Monad. Each tool covers a necessary function without overloading.
The server covers scanning, identification, allowance checks, contract stats, and gas savings. Missing actionable tools like revoking approvals or cancelling subscriptions, but the stated focus is on monitoring and information.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for Boson Protocol — on-chain agentic commerce for physical & digital goods.
Abstraxn: public Web3 MCP server for read-only chain data and pay-per-call relays.
Tenzro Network MCP server: wallet, identity, payments, inference, staking, bridges, verification.
Hosted MCP server for live Bittensor chain reads and self-custodial on-chain writes.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn MCP server for checking and revoking ERC-20 token allowances across multiple blockchains.135MIT
- -licenseNot gradedqualityNot gradedmaintenanceAn MCP server that allows Claude Desktop to query Monad testnet for MON token balances of accounts.-
- AlicenseNot gradedqualityBmaintenanceNon-custodial MCP server that routes blockchain transactions to your browser wallet (MetaMask, Rabby, etc.) for signing — private keys never leave your browser.2MIT
- FlicenseCqualityDmaintenanceMCP server for managing web3 content, fetching blockchain data, and analyzing content for web3 topics.25-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Alicepoltora/sub-killer-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server