MERX - TRON Resource Exchange

Official66 toolsLive

by Hovsteder · TypeScript

TRON energy exchange for AI agents. 54 tools, 30 prompts, 21 resources. A2A + ACP.

exchange.merx/mcp — Model Context Protocol (MCP) Server

The exchange.merx/mcp server provides TRON infrastructure for AI agents via the Model Context Protocol (MCP). The cataloged package includes 54 tools, 30 prompts, and 21 resources (66 total). It is described as supporting A2A plus ACP, and is associated with MERX.exchange.

🛠️ Key Features

MCP server for TRON energy exchange
54 tools, 30 prompts, 21 resources
A2A + ACP support

🚀 Use Cases

TRON energy exchange interactions for AI agents
Agent workflows that leverage prompts and shared resources

⚡ Developer Benefits

Topic coverage for MCP, model context integration, and Web3/DeFi contexts
Large surface area: tools, prompts, and resources bundled in one server

⚠️ Limitations

Readme excerpt provided is partial and includes metadata/badges, not detailed usage or configuration.

Topics

ai-agentblockchainclaudecursordefimcpmcp-servermodel-context-protocolsunswaptrontron-energyusdtx402intent-executionresource-optimizationtrxweb3energy-delegationtron-bandwidth

Captured live from the server via tools/list.

get_prices

Get current energy and bandwidth prices from all Merx providers, sorted by best (minimum) price across all duration tiers. Each provider lists ALL its duration tiers (5min/1h/1d/7d/30d etc) — short rentals are usually more expensive per unit than long ones, so always check tier-by-tier. Optionally filter by exact duration in seconds. No auth required.

Parameters2

resource	string	optional	Filter by resource type. Omit for all.
duration	number	optional	Filter to providers offering this exact duration in seconds (e.g. 3600 for 1h, 86400 for 1d, 604800 for 7d, 2592000 for 30d). Omit to see all tiers.

Raw schema

{
  "type": "object",
  "properties": {
    "resource": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Filter by resource type. Omit for all."
    },
    "duration": {
      "type": "number",
      "description": "Filter to providers offering this exact duration in seconds (e.g. 3600 for 1h, 86400 for 1d, 604800 for 7d, 2592000 for 30d). Omit to see all tiers."
    }
  }
}

get_best_price

Quick lookup of the single cheapest provider for a resource type, with optional minimum amount filter. CAVEAT: this returns a single representative price per provider, not broken down by duration tier — short rentals (5min) and long rentals (30 days) have very different per-unit prices and this tool does not distinguish between them. For an accurate per-tier comparison, use get_prices(duration=N) where N is the exact rental duration in seconds (e.g. 3600 for 1h, 86400 for 1d, 2592000 for 30d). Use get_best_price only when you need the absolute floor price as a quick sanity-check. No auth required.

Parameters2

resource	string	required	Resource type.
amount	number	optional	Amount of resource units needed.

Raw schema

{
  "type": "object",
  "properties": {
    "resource": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Resource type."
    },
    "amount": {
      "type": "number",
      "description": "Amount of resource units needed."
    }
  },
  "required": [
    "resource"
  ]
}

analyze_prices

Market price analysis with trends and recommendations. No auth required.

Parameters1

resource

string

optional

Filter by resource type. Omit for all.

Raw schema

{
  "type": "object",
  "properties": {
    "resource": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Filter by resource type. Omit for all."
    }
  }
}

get_price_history

Historical price snapshots. No auth required.

Parameters3

resource	string	optional	Filter by resource type.
provider	string	optional	Filter by provider name.
period	string	optional	Time period (default: 24h).

Raw schema

{
  "type": "object",
  "properties": {
    "resource": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Filter by resource type."
    },
    "provider": {
      "type": "string",
      "description": "Filter by provider name."
    },
    "period": {
      "type": "string",
      "enum": [
        "1h",
        "6h",
        "24h",
        "7d",
        "30d"
      ],
      "description": "Time period (default: 24h)."
    }
  }
}

compare_providers

Side-by-side provider comparison with prices and availability. No auth required.

Parameters1

resource

string

optional

Filter by resource type. Omit for all.

Raw schema

{
  "type": "object",
  "properties": {
    "resource": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Filter by resource type. Omit for all."
    }
  }
}

estimate_transaction_cost

Estimate cost of a TRON transaction BEFORE sending. Aliases: estimate_cost, calculate_cost, transaction_cost, energy_cost, transfer_cost. Calculate exactly how much energy, bandwidth, and TRX a TRON transaction will cost before sending it. Use this to answer questions like "how much does a USDT transfer cost?" or "what will it cost me to send 100 USDT to address X?". Returns: energy units needed, bandwidth needed, TRX cost if you burn directly, and TRX cost if you rent energy from Merx (typically 70-80% cheaper). Supports trc20_transfer (e.g. USDT/USDC), trc20_approve, trx_transfer, and custom contract calls. No auth required.

Parameters8

operation	string	required	Transaction type.
from_address	string	optional	Sender TRON address.
to_address	string	optional	Recipient TRON address.
token_address	string	optional	TRC20 contract address.
amount	string	optional	Token amount (as string).
contract_address	string	optional	Contract address (custom).
function_selector	string	optional	Function selector (custom).
parameter	string	optional	ABI-encoded parameter (custom).

Raw schema

{
  "type": "object",
  "properties": {
    "operation": {
      "type": "string",
      "enum": [
        "trc20_transfer",
        "trc20_approve",
        "trx_transfer",
        "custom"
      ],
      "description": "Transaction type."
    },
    "from_address": {
      "type": "string",
      "description": "Sender TRON address."
    },
    "to_address": {
      "type": "string",
      "description": "Recipient TRON address."
    },
    "token_address": {
      "type": "string",
      "description": "TRC20 contract address."
    },
    "amount": {
      "type": "string",
      "description": "Token amount (as string)."
    },
    "contract_address": {
      "type": "string",
      "description": "Contract address (custom)."
    },
    "function_selector": {
      "type": "string",
      "description": "Function selector (custom)."
    },
    "parameter": {
      "type": "string",
      "description": "ABI-encoded parameter (custom)."
    }
  },
  "required": [
    "operation"
  ]
}

check_address_resources

Check energy, bandwidth, and TRX balance for any TRON address. No auth required.

Parameters1

address

string

required

TRON address (starts with T).

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address (starts with T)."
    }
  },
  "required": [
    "address"
  ]
}

create_order

Buy energy or bandwidth on Merx. Routed to cheapest provider. Auth required.

Parameters5

resource_type	string	required	Resource type to purchase.
amount	number	required	Amount of resource units (min 65000 for ENERGY, 300 for BANDWIDTH).
duration_sec	number	required	Rental duration in seconds (e.g. 300, 3600, 86400, 2592000).
target_address	string	required	TRON address to receive delegated resources.
max_price_sun	number	optional	Optional max price in SUN/unit. Order fails if no provider is cheaper.

Raw schema

{
  "type": "object",
  "properties": {
    "resource_type": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Resource type to purchase."
    },
    "amount": {
      "type": "number",
      "description": "Amount of resource units (min 65000 for ENERGY, 300 for BANDWIDTH)."
    },
    "duration_sec": {
      "type": "number",
      "description": "Rental duration in seconds (e.g. 300, 3600, 86400, 2592000)."
    },
    "target_address": {
      "type": "string",
      "description": "TRON address to receive delegated resources."
    },
    "max_price_sun": {
      "type": "number",
      "description": "Optional max price in SUN/unit. Order fails if no provider is cheaper."
    }
  },
  "required": [
    "resource_type",
    "amount",
    "duration_sec",
    "target_address"
  ]
}

get_order

Get order status by UUID. Aliases: get_order_status, check_order, order_status, order_details, fetch_order. Check the status and fill details of an existing order by its UUID. Returns current status (PENDING/FILLING/FILLED/PARTIAL/FAILED/CANCELLED), fill amounts, provider used, on-chain delegation tx hash if delivered. Use this to poll order progress after creating an order. Auth required (API key).

Parameters1

order_id

string

required

The order UUID.

Raw schema

{
  "type": "object",
  "properties": {
    "order_id": {
      "type": "string",
      "description": "The order UUID."
    }
  },
  "required": [
    "order_id"
  ]
}

list_orders

List recent orders with optional status filter. Auth required.

Parameters2

status	string	optional	Filter by order status.
limit	number	optional	Max number of orders to return (default: 20).

Raw schema

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "enum": [
        "PENDING",
        "FILLING",
        "FILLED",
        "PARTIAL",
        "FAILED",
        "CANCELLED"
      ],
      "description": "Filter by order status."
    },
    "limit": {
      "type": "number",
      "description": "Max number of orders to return (default: 20)."
    }
  }
}

ensure_resources

Declarative resource provisioning. Checks current resources on target address and purchases only what is missing. Auth required.

Parameters4

target_address	string	required	TRON address to provision resources for.
energy_minimum	number	optional	Minimum energy the address should have.
bandwidth_minimum	number	optional	Minimum bandwidth the address should have.
duration_sec	number	optional	Rental duration in seconds (default: 3600).

Raw schema

{
  "type": "object",
  "properties": {
    "target_address": {
      "type": "string",
      "description": "TRON address to provision resources for."
    },
    "energy_minimum": {
      "type": "number",
      "description": "Minimum energy the address should have."
    },
    "bandwidth_minimum": {
      "type": "number",
      "description": "Minimum bandwidth the address should have."
    },
    "duration_sec": {
      "type": "number",
      "description": "Rental duration in seconds (default: 3600)."
    }
  },
  "required": [
    "target_address"
  ]
}

wait_for_delegation

Block until an order reaches a terminal state (FILLED, PARTIAL, FAILED, or CANCELLED) by polling get_order at fixed intervals. Use this right after create_order when you need to confirm the energy/bandwidth has actually been delegated on-chain before sending the next transaction. Returns the final order details including the on-chain delegation tx hash. Auth required.

Parameters3

order_id	string	required	The order UUID returned by create_order.
timeout_sec	number	optional	Maximum time to wait in seconds (default: 60, max: 300).
poll_interval_sec	number	optional	How often to check status in seconds (default: 3, min: 1).

Raw schema

{
  "type": "object",
  "properties": {
    "order_id": {
      "type": "string",
      "description": "The order UUID returned by create_order."
    },
    "timeout_sec": {
      "type": "number",
      "description": "Maximum time to wait in seconds (default: 60, max: 300)."
    },
    "poll_interval_sec": {
      "type": "number",
      "description": "How often to check status in seconds (default: 3, min: 1)."
    }
  },
  "required": [
    "order_id"
  ]
}

get_balance

Get your Merx account balance (TRX, USDT, locked). Requires MERX_API_KEY.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

get_deposit_info

Get your Merx deposit address and memo. Requires MERX_API_KEY.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

get_transaction_history

Get your Merx account transaction history. Requires MERX_API_KEY.

Parameters1

period

string

optional

Time period to query. Default: 30D.

Raw schema

{
  "type": "object",
  "properties": {
    "period": {
      "type": "string",
      "enum": [
        "7D",
        "30D",
        "90D"
      ],
      "description": "Time period to query. Default: 30D."
    }
  }
}

explain_concept

Explain a TRON or Merx concept in plain language. Hardcoded topics (exact match): energy, bandwidth, staking, delegation, sun_units, burn_vs_rent, merx_routing, provider_types. The lookup is fuzzy — substring matches also work, so "rent" finds "burn_vs_rent" and "providers" finds "provider_types". For topics outside this list (e.g. x402, stablecoins, gasfree), pick the closest hardcoded topic, or just answer the question yourself from the broader context — this tool only returns canned explanations of TRON resource economics.

Parameters1

topic

string

required

Topic to explain. Exact: energy, bandwidth, staking, delegation, sun_units, burn_vs_rent, merx_routing, provider_types. Fuzzy substrings (e.g. "rent", "providers") also work.

Raw schema

{
  "type": "object",
  "properties": {
    "topic": {
      "type": "string",
      "description": "Topic to explain. Exact: energy, bandwidth, staking, delegation, sun_units, burn_vs_rent, merx_routing, provider_types. Fuzzy substrings (e.g. \"rent\", \"providers\") also work."
    }
  },
  "required": [
    "topic"
  ]
}

suggest_duration

Recommend a rental duration based on your use case. No authentication required.

Parameters2

use_case	string	required	Your intended use case.
transaction_count	number	optional	Expected number of transactions (optional).

Raw schema

{
  "type": "object",
  "properties": {
    "use_case": {
      "type": "string",
      "enum": [
        "single_transfer",
        "batch_transfers",
        "dapp_session",
        "daily_operations",
        "weekly_operations",
        "monthly_budget"
      ],
      "description": "Your intended use case."
    },
    "transaction_count": {
      "type": "number",
      "description": "Expected number of transactions (optional)."
    }
  },
  "required": [
    "use_case"
  ]
}

calculate_savings

Calculate savings from renting energy vs burning TRX. No authentication required.

Parameters2

operation	string	optional	Operation type. Default: trc20_transfer.
transaction_count	number	optional	Number of transactions. Default: 1.

Raw schema

{
  "type": "object",
  "properties": {
    "operation": {
      "type": "string",
      "enum": [
        "trc20_transfer",
        "trc20_approve",
        "trx_transfer"
      ],
      "description": "Operation type. Default: trc20_transfer."
    },
    "transaction_count": {
      "type": "number",
      "description": "Number of transactions. Default: 1."
    }
  }
}

list_providers

List all Merx providers with types, durations, and availability. No authentication required.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

get_account_info

Inspect any TRON address. Aliases: check_address, get_address_info, get_wallet_info, address_info, account_status. Read the full on-chain state of ANY TRON address (does not have to be your own): TRX balance, free + delegated energy, free + delegated bandwidth, frozen TRX, account creation timestamp. Use this to check if an address has enough resources before sending a transaction, or to inspect any TRON wallet. No auth required, no API key needed.

Parameters1

address

string

required

TRON address (T...).

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address (T...)."
    }
  },
  "required": [
    "address"
  ]
}

get_trx_balance

Quick TRX balance for a TRON address. No auth required.

Parameters1

address

string

required

TRON address (T...).

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address (T...)."
    }
  },
  "required": [
    "address"
  ]
}

get_trc20_balance

Get TRC-20 token balance for an address. Supports symbol (USDT, USDC) or contract address. No auth required.

Parameters2

address	string	required	TRON address to query.
token	string	required	Token symbol (USDT, USDC) or contract address.

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address to query."
    },
    "token": {
      "type": "string",
      "description": "Token symbol (USDT, USDC) or contract address."
    }
  },
  "required": [
    "address",
    "token"
  ]
}

get_transaction

Look up a transaction by ID on TRON. No auth required.

Parameters1

tx_id

string

required

Transaction ID (hash).

Raw schema

{
  "type": "object",
  "properties": {
    "tx_id": {
      "type": "string",
      "description": "Transaction ID (hash)."
    }
  },
  "required": [
    "tx_id"
  ]
}

get_block

Get TRON block info by number (or latest if omitted). No auth required.

Parameters1

block_number

number

optional

Block number. Omit for latest.

Raw schema

{
  "type": "object",
  "properties": {
    "block_number": {
      "type": "number",
      "description": "Block number. Omit for latest."
    }
  }
}

get_chain_parameters

Get TRON network parameters (energy fee, bandwidth cost, etc.) with Merx price comparison. No auth required.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

convert_address

Convert TRON address between base58 (T...) and hex (41...) formats. No auth required.

Parameters1

address

string

required

TRON address in base58 (T...) or hex (41...).

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address in base58 (T...) or hex (41...)."
    }
  },
  "required": [
    "address"
  ]
}

get_trx_price

Get current TRX price from CoinGecko. No auth required.

Parameters1

currency

string

optional

Fiat currency code (default: usd).

Raw schema

{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string",
      "description": "Fiat currency code (default: usd)."
    }
  }
}

validate_address

Validate a TRON address format and check on-chain status. No auth required.

Parameters1

address

string

required

TRON address to validate.

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address to validate."
    }
  },
  "required": [
    "address"
  ]
}

search_transaction_history

Get on-chain transaction history for a TRON address. No auth required.

Parameters3

address	string	required	TRON address.
type	string	optional	Transaction type filter (default: all).
limit	number	optional	Max results (default: 20).

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address."
    },
    "type": {
      "type": "string",
      "enum": [
        "all",
        "trx",
        "trc20"
      ],
      "description": "Transaction type filter (default: all)."
    },
    "limit": {
      "type": "number",
      "description": "Max results (default: 20)."
    }
  },
  "required": [
    "address"
  ]
}

transfer_trx

Send TRX to an address. Checks bandwidth, buys via Merx if needed. Signs and broadcasts on-chain. Requires TRON_PRIVATE_KEY.

Parameters2

to_address	string	required	Recipient TRON address.
amount_trx	string	required	Amount of TRX to send.

Raw schema

{
  "type": "object",
  "properties": {
    "to_address": {
      "type": "string",
      "description": "Recipient TRON address."
    },
    "amount_trx": {
      "type": "string",
      "description": "Amount of TRX to send."
    }
  },
  "required": [
    "to_address",
    "amount_trx"
  ]
}

transfer_trc20

Transfer TRC-20 tokens with automatic energy optimization. Signs and broadcasts on-chain. Requires TRON_PRIVATE_KEY.

Parameters3

to_address	string	required	Recipient TRON address.
token	string	required	Token symbol (USDT, USDC) or contract address.
amount	string	required	Amount to transfer (human-readable).

Raw schema

{
  "type": "object",
  "properties": {
    "to_address": {
      "type": "string",
      "description": "Recipient TRON address."
    },
    "token": {
      "type": "string",
      "description": "Token symbol (USDT, USDC) or contract address."
    },
    "amount": {
      "type": "string",
      "description": "Amount to transfer (human-readable)."
    }
  },
  "required": [
    "to_address",
    "token",
    "amount"
  ]
}

approve_trc20

Approve TRC-20 spending allowance. Signs and broadcasts on-chain. Requires TRON_PRIVATE_KEY.

Parameters3

token	string	required	Token symbol or contract address.
spender	string	required	Spender TRON address.
amount	string	required	Allowance amount (human-readable, or "unlimited").

Raw schema

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "description": "Token symbol or contract address."
    },
    "spender": {
      "type": "string",
      "description": "Spender TRON address."
    },
    "amount": {
      "type": "string",
      "description": "Allowance amount (human-readable, or \"unlimited\")."
    }
  },
  "required": [
    "token",
    "spender",
    "amount"
  ]
}

get_token_info

Get TRC-20 token metadata: name, symbol, decimals, total supply. No auth required.

Parameters1

token

string

required

Token symbol or contract address.

Raw schema

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "description": "Token symbol or contract address."
    }
  },
  "required": [
    "token"
  ]
}

read_contract

Call a view/pure function on a TRON smart contract. No auth or private key required.

Parameters3

contract_address	string	required	Contract TRON address.
function_selector	string	required	Function signature, e.g. "balanceOf(address)".
parameter	string	optional	ABI-encoded parameter hex (optional).

Raw schema

{
  "type": "object",
  "properties": {
    "contract_address": {
      "type": "string",
      "description": "Contract TRON address."
    },
    "function_selector": {
      "type": "string",
      "description": "Function signature, e.g. \"balanceOf(address)\"."
    },
    "parameter": {
      "type": "string",
      "description": "ABI-encoded parameter hex (optional)."
    }
  },
  "required": [
    "contract_address",
    "function_selector"
  ]
}

estimate_contract_call

Estimate energy and bandwidth cost for a smart contract call. Compares rental vs burn cost. No auth required.

Parameters4

contract_address	string	required	Contract TRON address.
function_selector	string	required	Function signature, e.g. "transfer(address,uint256)".
parameter	string	optional	ABI-encoded parameter hex (optional).
caller_address	string	optional	Caller TRON address for simulation (optional).

Raw schema

{
  "type": "object",
  "properties": {
    "contract_address": {
      "type": "string",
      "description": "Contract TRON address."
    },
    "function_selector": {
      "type": "string",
      "description": "Function signature, e.g. \"transfer(address,uint256)\"."
    },
    "parameter": {
      "type": "string",
      "description": "ABI-encoded parameter hex (optional)."
    },
    "caller_address": {
      "type": "string",
      "description": "Caller TRON address for simulation (optional)."
    }
  },
  "required": [
    "contract_address",
    "function_selector"
  ]
}

call_contract

Execute a state-changing smart contract function. Estimates resources, buys via Merx if needed. Requires TRON_PRIVATE_KEY and TRON_ADDRESS.

Parameters4

contract_address	string	required	Contract TRON address.
function_selector	string	required	Function signature, e.g. "stake(uint256)".
parameter	string	optional	ABI-encoded parameter hex (optional).
call_value_trx	string	optional	TRX to send with call (optional).

Raw schema

{
  "type": "object",
  "properties": {
    "contract_address": {
      "type": "string",
      "description": "Contract TRON address."
    },
    "function_selector": {
      "type": "string",
      "description": "Function signature, e.g. \"stake(uint256)\"."
    },
    "parameter": {
      "type": "string",
      "description": "ABI-encoded parameter hex (optional)."
    },
    "call_value_trx": {
      "type": "string",
      "description": "TRX to send with call (optional)."
    }
  },
  "required": [
    "contract_address",
    "function_selector"
  ]
}

get_contract_info

Get on-chain metadata for a TRON smart contract: existence check, owner address, energy origin, code hash, contract name (if set), ABI entries count. Use this to check whether an address is a contract before calling read_contract or estimate_contract_call. For TRC20-specific metadata (name, symbol, decimals, totalSupply) use get_token_info instead. No auth required.

Parameters1

address

string

required

Contract TRON address (T...)

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "Contract TRON address (T...)"
    }
  },
  "required": [
    "address"
  ]
}

get_swap_quote

Get a real swap quote from SunSwap V2. No auth required.

Parameters4

from_token	string	required	Source token symbol (TRX, USDT, USDC, etc.)
to_token	string	required	Destination token symbol
amount	string	required	Amount of source token to swap
slippage	number	optional	Slippage tolerance in percent (default 1)

Raw schema

{
  "type": "object",
  "properties": {
    "from_token": {
      "type": "string",
      "description": "Source token symbol (TRX, USDT, USDC, etc.)"
    },
    "to_token": {
      "type": "string",
      "description": "Destination token symbol"
    },
    "amount": {
      "type": "string",
      "description": "Amount of source token to swap"
    },
    "slippage": {
      "type": "number",
      "description": "Slippage tolerance in percent (default 1)"
    }
  },
  "required": [
    "from_token",
    "to_token",
    "amount"
  ]
}

execute_swap

Execute a token swap on SunSwap V2. Requires TRON_PRIVATE_KEY.

Parameters4

from_token	string	required	Source token symbol (TRX, USDT, USDC, etc.)
to_token	string	required	Destination token symbol
amount	string	required	Amount of source token to swap
slippage	number	optional	Slippage tolerance in percent (default 1)

Raw schema

{
  "type": "object",
  "properties": {
    "from_token": {
      "type": "string",
      "description": "Source token symbol (TRX, USDT, USDC, etc.)"
    },
    "to_token": {
      "type": "string",
      "description": "Destination token symbol"
    },
    "amount": {
      "type": "string",
      "description": "Amount of source token to swap"
    },
    "slippage": {
      "type": "number",
      "description": "Slippage tolerance in percent (default 1)"
    }
  },
  "required": [
    "from_token",
    "to_token",
    "amount"
  ]
}

get_token_price

Get token price via SunSwap quote + CoinGecko USD rate. No auth required.

Parameters1

token

string

required

Token symbol (USDT, USDC, SUN, etc.)

Raw schema

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "description": "Token symbol (USDT, USDC, SUN, etc.)"
    }
  },
  "required": [
    "token"
  ]
}

create_account

Create a new Merx account, generate an API key, and get deposit info. No auth needed.

Parameters2

email	string	required	Email address for the account
password	string	required	Password (min 8 characters)

Raw schema

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "Email address for the account"
    },
    "password": {
      "type": "string",
      "description": "Password (min 8 characters)"
    }
  },
  "required": [
    "email",
    "password"
  ]
}

login

Parameters2

email	string	required	Email address
password	string	required	Password

Raw schema

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "Email address"
    },
    "password": {
      "type": "string",
      "description": "Password"
    }
  },
  "required": [
    "email",
    "password"
  ]
}

set_api_key

Set your Merx API key for this session. Unlocks all authenticated tools (trading, balance, orders). Use this if you already have an API key.

Parameters1

api_key

string

required

Your Merx API key (starts with sk_live_)

Raw schema

{
  "type": "object",
  "properties": {
    "api_key": {
      "type": "string",
      "description": "Your Merx API key (starts with sk_live_)"
    }
  },
  "required": [
    "api_key"
  ]
}

set_private_key

Set your TRON private key for this session. Address is derived automatically. Enables write tools: transfer_trx, transfer_trc20, approve_trc20, execute_swap, deposit_trx. Key stays local - never sent to Merx servers.

Parameters1

private_key

string

required

Your TRON private key (64 hex characters)

Raw schema

{
  "type": "object",
  "properties": {
    "private_key": {
      "type": "string",
      "description": "Your TRON private key (64 hex characters)"
    }
  },
  "required": [
    "private_key"
  ]
}

deposit_trx

Deposit TRX to your Merx account. Requires MERX_API_KEY + TRON_PRIVATE_KEY.

Parameters1

amount_trx

string

required

Amount of TRX to deposit

Raw schema

{
  "type": "object",
  "properties": {
    "amount_trx": {
      "type": "string",
      "description": "Amount of TRX to deposit"
    }
  },
  "required": [
    "amount_trx"
  ]
}

enable_auto_deposit

Configure automatic top-up when balance drops below a threshold. The configuration lives ONLY in the current MCP session — it is held in memory by the MCP server process and is lost on server restart, MCP client reconnect, or server redeploy. Top-ups are signed locally with TRON_PRIVATE_KEY and sent to your Merx deposit address (memo-routed). For persistent auto-deposit you currently need to call this tool again at the start of each session.

Parameters3

threshold_trx	string	required	Balance threshold in TRX
deposit_amount_trx	string	required	Amount of TRX per deposit
max_daily_deposits	number	optional	Max deposits per day (default 5)

Raw schema

{
  "type": "object",
  "properties": {
    "threshold_trx": {
      "type": "string",
      "description": "Balance threshold in TRX"
    },
    "deposit_amount_trx": {
      "type": "string",
      "description": "Amount of TRX per deposit"
    },
    "max_daily_deposits": {
      "type": "number",
      "description": "Max deposits per day (default 5)"
    }
  },
  "required": [
    "threshold_trx",
    "deposit_amount_trx"
  ]
}

pay_invoice

Pay an x402 invoice by signing and broadcasting a TRX transfer to the invoice address, then verifying the payment with the facilitator. x402 (Coinbase + Cloudflare HTTP 402 standard) is the protocol AI agents use to pay APIs per call. Use this when you receive an invoice_id from a paywalled service or another agent. REQUIRES: TRON_PRIVATE_KEY in env (use set_private_key first) AND a valid invoice_id from create_invoice or x402 challenge response. The transfer is signed locally — your private key never leaves the MCP process.

Parameters1

invoice_id

string

required

Invoice ID to pay

Raw schema

{
  "type": "object",
  "properties": {
    "invoice_id": {
      "type": "string",
      "description": "Invoice ID to pay"
    }
  },
  "required": [
    "invoice_id"
  ]
}

create_paid_order

Create a zero-registration order via x402 pay-per-use. Requires TRON_PRIVATE_KEY.

Parameters4

resource_type	string	required	Resource type
amount	number	required	Amount of resource units
duration_sec	number	required	Duration in seconds
target_address	string	required	TRON address to receive resources

Raw schema

{
  "type": "object",
  "properties": {
    "resource_type": {
      "type": "string",
      "enum": [
        "ENERGY",
        "BANDWIDTH"
      ],
      "description": "Resource type"
    },
    "amount": {
      "type": "number",
      "description": "Amount of resource units"
    },
    "duration_sec": {
      "type": "number",
      "description": "Duration in seconds"
    },
    "target_address": {
      "type": "string",
      "description": "TRON address to receive resources"
    }
  },
  "required": [
    "resource_type",
    "amount",
    "duration_sec",
    "target_address"
  ]
}

execute_intent

Plan a multi-step operation (transfer, swap, buy resources, etc) and return a cost estimate, total energy/bandwidth needed, and the cheapest resource acquisition strategy. NOTE: actual on-chain execution of multi-step intents is not yet wired up — currently returns the same plan as simulate, regardless of dry_run. Use this for planning; for real execution call the underlying tools (create_order, transfer_trc20, execute_swap) yourself in sequence. Auth required.

Parameters3

steps	array	required	Array of { action, params } steps to execute.
resource_strategy	string	optional	Resource acquisition strategy (default: batch_cheapest).
dry_run	boolean	optional	If true, simulate only without executing (default: false).

Raw schema

{
  "type": "object",
  "properties": {
    "steps": {
      "type": "array",
      "description": "Array of { action, params } steps to execute."
    },
    "resource_strategy": {
      "type": "string",
      "enum": [
        "batch_cheapest",
        "per_step",
        "no_resources"
      ],
      "description": "Resource acquisition strategy (default: batch_cheapest)."
    },
    "dry_run": {
      "type": "boolean",
      "description": "If true, simulate only without executing (default: false)."
    }
  },
  "required": [
    "steps"
  ]
}

simulate

Dry-run a multi-step operation (transfer, swap, buy resources, etc) without sending anything on-chain. Returns per-step energy and bandwidth estimates plus a total TRX cost. Use this to preview a plan before committing — for example, before transferring USDT to multiple recipients you can simulate to see the total energy cost. No auth required.

Parameters2

steps	array	required	Array of { action, params } steps to simulate.
resource_strategy	string	optional	Resource acquisition strategy (default: batch_cheapest).

Raw schema

{
  "type": "object",
  "properties": {
    "steps": {
      "type": "array",
      "description": "Array of { action, params } steps to simulate."
    },
    "resource_strategy": {
      "type": "string",
      "enum": [
        "batch_cheapest",
        "per_step",
        "no_resources"
      ],
      "description": "Resource acquisition strategy (default: batch_cheapest)."
    }
  },
  "required": [
    "steps"
  ]
}

create_standing_order

Create a server-side standing order with trigger-based automation. Auth required.

Parameters7

trigger_type	string	required	Condition that triggers the order.
trigger_params	object	required	Trigger parameters: { resource, threshold_sun } or { cron }.
action_type	string	required	Action to perform when triggered.
action_params	object	required	Action parameters: { resource_type, amount, duration_sec, target_address }.
budget_trx	string	required	Maximum budget in TRX (converted to SUN internally).
max_executions	number	required	Maximum number of times this order can execute.
expires_at	string	optional	ISO 8601 expiration date (optional).

Raw schema

{
  "type": "object",
  "properties": {
    "trigger_type": {
      "type": "string",
      "enum": [
        "price_below",
        "price_above",
        "schedule",
        "balance_below"
      ],
      "description": "Condition that triggers the order."
    },
    "trigger_params": {
      "type": "object",
      "description": "Trigger parameters: { resource, threshold_sun } or { cron }."
    },
    "action_type": {
      "type": "string",
      "enum": [
        "buy_resource",
        "ensure_resources",
        "notify_only"
      ],
      "description": "Action to perform when triggered."
    },
    "action_params": {
      "type": "object",
      "description": "Action parameters: { resource_type, amount, duration_sec, target_address }."
    },
    "budget_trx": {
      "type": "string",
      "description": "Maximum budget in TRX (converted to SUN internally)."
    },
    "max_executions": {
      "type": "number",
      "description": "Maximum number of times this order can execute."
    },
    "expires_at": {
      "type": "string",
      "description": "ISO 8601 expiration date (optional)."
    }
  },
  "required": [
    "trigger_type",
    "trigger_params",
    "action_type",
    "action_params",
    "budget_trx",
    "max_executions"
  ]
}

list_standing_orders

List all standing orders with optional status filter. Auth required.

Parameters1

status

string

optional

Filter by status.

Raw schema

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "enum": [
        "ACTIVE",
        "TRIGGERED",
        "EXHAUSTED",
        "EXPIRED",
        "CANCELLED"
      ],
      "description": "Filter by status."
    }
  }
}

get_standing_order

Get full details of a single standing order by its UUID. Returns trigger config, action params, budget, executions count, and status. Auth required (API key).

Parameters1

order_id

string

required

Standing order UUID (from list_standing_orders).

Raw schema

{
  "type": "object",
  "properties": {
    "order_id": {
      "type": "string",
      "description": "Standing order UUID (from list_standing_orders)."
    }
  },
  "required": [
    "order_id"
  ]
}

cancel_standing_order

Cancel a standing order by its UUID. The order is moved to CANCELLED status and will not trigger again. Already-executed actions are NOT reversed. Auth required (API key).

Parameters1

order_id

string

required

Standing order UUID to cancel.

Raw schema

{
  "type": "object",
  "properties": {
    "order_id": {
      "type": "string",
      "description": "Standing order UUID to cancel."
    }
  },
  "required": [
    "order_id"
  ]
}

create_monitor

Create a persistent server-side monitor that fires notifications when a condition is met. Four monitor types: delegation_expiry (warns when leased energy is about to expire so you can re-rent), balance_threshold (fires when an address goes below a TRX/USDT level), price_alert (fires when energy/bandwidth price crosses a SUN threshold), address_activity (fires on any incoming TX). Notification defaults to webhook=true if omitted. Auth required (API key).

Parameters4

monitor_type	string	required	Type of monitor to create.
target_address	string	optional	TRON address to monitor. Required for delegation_expiry, balance_threshold, address_activity. Not used for price_alert.
params	object	required	Type-specific params. delegation_expiry: { alert_before_sec, auto_renew, resource_type }. balance_threshold: { resource: "TRX"\|"ENERGY"\|"BANDWIDTH", below: number }. price_alert: { resource: "ENERGY"\|"BANDWIDTH", above_sun?: number, below_sun?: number }. address_activity: { min_amount_trx?: number }.
notify	object	optional	Notification config: { webhook?: boolean, telegram_chat_id?: string }. Defaults to { webhook: true } if omitted.

Raw schema

{
  "type": "object",
  "properties": {
    "monitor_type": {
      "type": "string",
      "enum": [
        "delegation_expiry",
        "balance_threshold",
        "price_alert",
        "address_activity"
      ],
      "description": "Type of monitor to create."
    },
    "target_address": {
      "type": "string",
      "description": "TRON address to monitor. Required for delegation_expiry, balance_threshold, address_activity. Not used for price_alert."
    },
    "params": {
      "type": "object",
      "description": "Type-specific params. delegation_expiry: { alert_before_sec, auto_renew, resource_type }. balance_threshold: { resource: \"TRX\"|\"ENERGY\"|\"BANDWIDTH\", below: number }. price_alert: { resource: \"ENERGY\"|\"BANDWIDTH\", above_sun?: number, below_sun?: number }. address_activity: { min_amount_trx?: number }."
    },
    "notify": {
      "type": "object",
      "description": "Notification config: { webhook?: boolean, telegram_chat_id?: string }. Defaults to { webhook: true } if omitted."
    }
  },
  "required": [
    "monitor_type",
    "params"
  ]
}

list_monitors

List all monitors you created with create_monitor, optionally filtered by status (ACTIVE/CANCELLED). Each row shows the full monitor UUID (pass to cancel_monitor), monitor type, target address, and status. Note: the Target column will be empty for monitor types that do not have a single watched address — specifically price_alert and balance_threshold (when watching the API key holder rather than a third-party address). For delegation_expiry and address_activity monitors, Target will always be set. Auth required (API key).

Parameters1

status

string

optional

Filter by monitor status.

Raw schema

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "enum": [
        "ACTIVE",
        "CANCELLED"
      ],
      "description": "Filter by monitor status."
    }
  }
}

cancel_monitor

Cancel an active monitor by its UUID. The monitor stops firing notifications. Auth required (API key).

Parameters1

monitor_id

string

required

Monitor UUID to cancel.

Raw schema

{
  "type": "object",
  "properties": {
    "monitor_id": {
      "type": "string",
      "description": "Monitor UUID to cancel."
    }
  },
  "required": [
    "monitor_id"
  ]
}

withdraw

Withdraw TRX or USDT from your Merx account to an external TRON address. The "amount" parameter is interpreted in the currency specified by "currency" — i.e. for currency=TRX it is TRX units, for currency=USDT it is USDT units. (The legacy parameter "amount_trx" is still accepted as an alias for backwards compatibility, but is misleading when currency is USDT — prefer "amount" in new code.) Requires MERX_API_KEY.

Parameters4

address	string	required	Destination TRON address (starts with T).
amount	string	optional	Amount to withdraw, in units of the chosen currency. E.g. "100" with currency=TRX = 100 TRX, "100" with currency=USDT = 100 USDT.
currency	string	optional	Currency to withdraw. Default: TRX.
amount_trx	string	optional	DEPRECATED alias for "amount" — kept for backwards compatibility. Pass "amount" instead in new code.

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "Destination TRON address (starts with T)."
    },
    "amount": {
      "type": "string",
      "description": "Amount to withdraw, in units of the chosen currency. E.g. \"100\" with currency=TRX = 100 TRX, \"100\" with currency=USDT = 100 USDT."
    },
    "currency": {
      "type": "string",
      "enum": [
        "TRX",
        "USDT"
      ],
      "description": "Currency to withdraw. Default: TRX."
    },
    "amount_trx": {
      "type": "string",
      "description": "DEPRECATED alias for \"amount\" — kept for backwards compatibility. Pass \"amount\" instead in new code."
    }
  },
  "required": [
    "address"
  ]
}

compile_policy

Convert a natural language energy management policy into MERX automation. Creates standing orders and monitors based on your instructions. Examples: - "Keep 500k energy on my wallet, buy when price is below 55 SUN, max 200 TRX/week" - "Buy energy every day at 6 AM UTC, 1 million units, for 24 hours" - "Alert me when my energy drops below 100k" Returns a preview of what will be created. Set apply=true to execute.

Parameters3

instruction	string	required	Natural language description of the desired automation policy
address	string	optional	TRON address this policy applies to (optional)
apply	boolean	optional	Set to true to create the standing orders. Default false (preview only).

Raw schema

{
  "type": "object",
  "properties": {
    "instruction": {
      "type": "string",
      "description": "Natural language description of the desired automation policy"
    },
    "address": {
      "type": "string",
      "description": "TRON address this policy applies to (optional)"
    },
    "apply": {
      "type": "boolean",
      "description": "Set to true to create the standing orders. Default false (preview only)."
    }
  },
  "required": [
    "instruction"
  ]
}

resource_broadcast

Broadcast a signed TRON transaction with automatic energy optimization. If the target address lacks sufficient energy, MERX purchases the deficit at the best market price before broadcasting. One call: estimate, buy energy, wait for delegation, broadcast. Requires MERX_API_KEY with the "broadcast" scope, and a pre-signed transaction. Returns txid on success, refunds on timeout. NOTE: This endpoint is currently behind a feature flag and disabled by default in production. If you get a 503 MAINTENANCE error, use the manual flow instead: call ensure_resources to provision energy, then sign and broadcast the transaction with your own TronWeb client.

Parameters2

signed_tx	string	required	Hex-encoded signed TRON transaction
target_address	string	required	TRON address that will execute the transaction (must match TX sender)

Raw schema

{
  "type": "object",
  "properties": {
    "signed_tx": {
      "type": "string",
      "description": "Hex-encoded signed TRON transaction"
    },
    "target_address": {
      "type": "string",
      "description": "TRON address that will execute the transaction (must match TX sender)"
    }
  },
  "required": [
    "signed_tx",
    "target_address"
  ]
}

register_agent

Register your TRON address as an agent on agent.merx.exchange. Required ONCE before using request_payment, create_invoice, watch_address, agent_status, or any other agent payment tool. Pass the TRON address you want to use as the on-chain identity for this API key. Idempotent — calling twice with the same key returns the existing registration. Auth required (API key).

Parameters2

tron_address	string	required	Your TRON address (T...) that will receive payments and act as the agent identity.
label	string	optional	Optional human-readable label (max 64 chars)

Raw schema

{
  "type": "object",
  "properties": {
    "tron_address": {
      "type": "string",
      "description": "Your TRON address (T...) that will receive payments and act as the agent identity."
    },
    "label": {
      "type": "string",
      "description": "Optional human-readable label (max 64 chars)"
    }
  },
  "required": [
    "tron_address"
  ]
}

request_payment

Create a TRC20 payment request on TRON (USDT, USDC, USDD, or any TRC20). Returns a payment address. Fires webhook when payment arrives (<3 seconds). Use for receiving payments from other agents or humans. Requires agent registration first — call register_agent if you get AGENT_NOT_REGISTERED error.

Parameters5

amount_usdt	string	required	Amount in token units (e.g. "5.00")
description	string	optional	What this payment is for
timeout_seconds	number	optional	Wait timeout (10-3600, default 300)
tolerance_pct	number	optional	Amount tolerance % (default 0 = exact)
webhook_url	string	optional	URL to notify on payment (optional)

Raw schema

{
  "type": "object",
  "properties": {
    "amount_usdt": {
      "type": "string",
      "description": "Amount in token units (e.g. \"5.00\")"
    },
    "description": {
      "type": "string",
      "description": "What this payment is for"
    },
    "timeout_seconds": {
      "type": "number",
      "description": "Wait timeout (10-3600, default 300)"
    },
    "tolerance_pct": {
      "type": "number",
      "description": "Amount tolerance % (default 0 = exact)"
    },
    "webhook_url": {
      "type": "string",
      "description": "URL to notify on payment (optional)"
    }
  },
  "required": [
    "amount_usdt"
  ]
}

lookup_invoice

Look up a MERX invoice. Shows amount, recipient, token, and status. Agent must sign and broadcast the transfer separately (non-custodial).

Parameters1

invoice_id

string

required

Invoice UUID (e.g. eaa00c4e-1234-5678-90ab-cdef12345678) returned by create_invoice, or a full payment URL containing /pay/<uuid>.

Raw schema

{
  "type": "object",
  "properties": {
    "invoice_id": {
      "type": "string",
      "description": "Invoice UUID (e.g. eaa00c4e-1234-5678-90ab-cdef12345678) returned by create_invoice, or a full payment URL containing /pay/<uuid>."
    }
  },
  "required": [
    "invoice_id"
  ]
}

create_invoice

Create an invoice for another agent or human to pay. Returns payment URL, address, and QR code. Payment is detected automatically via ZeroMQ (<3 seconds).

Parameters3

amount_usdt	string	required	Amount in USDT
description	string	optional	What the invoice is for
expires_in	number	optional	Expiry in seconds (60-86400, default 3600)

Raw schema

{
  "type": "object",
  "properties": {
    "amount_usdt": {
      "type": "string",
      "description": "Amount in USDT"
    },
    "description": {
      "type": "string",
      "description": "What the invoice is for"
    },
    "expires_in": {
      "type": "number",
      "description": "Expiry in seconds (60-86400, default 3600)"
    }
  },
  "required": [
    "amount_usdt"
  ]
}

watch_address

Watch any TRON address for TRC20 transfers (USDT, USDC, USDD, or any token). Fires webhook on each matching transfer. Persistent - runs 24/7 even when conversation ends.

Parameters5

address	string	required	TRON address to watch (T...)
event_types	array	optional	Event types to watch
min_amount_usdt	string	optional	Minimum amount filter (default "0")
webhook_url	string	required	Webhook URL for notifications
ttl_hours	number	optional	Watch duration in hours (1-720, default 24)

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "TRON address to watch (T...)"
    },
    "event_types": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "usdt_incoming",
          "usdt_outgoing",
          "trx_incoming"
        ]
      },
      "description": "Event types to watch"
    },
    "min_amount_usdt": {
      "type": "string",
      "description": "Minimum amount filter (default \"0\")"
    },
    "webhook_url": {
      "type": "string",
      "description": "Webhook URL for notifications"
    },
    "ttl_hours": {
      "type": "number",
      "description": "Watch duration in hours (1-720, default 24)"
    }
  },
  "required": [
    "address",
    "webhook_url"
  ]
}

agent_status

Get a snapshot of your agent payment service: registered TRON address, count of pending payment requests (request_payment), active address watches (watch_address), and outstanding invoices (create_invoice). Use this right after register_agent to confirm the agent is set up, or any time you want to see how much in-flight activity your agent has. Auth required (API key) and agent must be registered first via register_agent.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

README.md54 KBView on GitHub

MERX

https://MERX.exchange

TRON infrastructure for AI agents.

Tools Prompts Resources

66 MCP tools. Energy market across 6 providers. USDT/USDC/USDD payments. x402 v2 facilitator on TRON mainnet.

Documentation | API Reference | MCP Server

What is MERX — TRON infrastructure for AI agents
The problem — why TRON had no agent layer until MERX
Platform overview — MCP, agent payment service, x402, GasFree, energy aggregator
Quick start — 4 paths (web, REST/SDK, Claude Code plugin, MCP)
What sets MERX apart — only complete agent stack on TRON
Architecture
API overview
MCP server
SDKs
Real-time data
Payment methods
Standing orders and monitors
Savings calculator
Error handling
Security
Tested on mainnet
Comparison with alternatives
Documentation
License

What is MERX

MERX is the infrastructure layer for AI agents and agentic networks on TRON. Where Stripe is infrastructure for web commerce and Cloudflare for the open web, MERX is the missing infrastructure layer that lets autonomous AI agents discover, transact, and operate on TRON without ever touching energy, bandwidth, or low-level blockchain mechanics.

The platform exposes one coherent stack: 66-tool MCP server, agent payment service for TRC-20 stablecoins, x402 v2 facilitator (the only TRON facilitator in the coinbase/x402 ecosystem registry), GasFree transfers via a MERX-deployed mainnet controller, dedicated TRON RPC node, A2A (Google, 7 skills) and ACP (BeeAI, 7 capabilities) protocol coverage, and a natural language Policy Engine powered by Anthropic Claude.

Underneath those agent surfaces sits an energy aggregator across 6 active providers (CatFee, Netts, TronSave, iTRX, PowerSun, TEM) that routes resource purchases to the cheapest source automatically -- so when an agent calls send(), MERX estimates the energy required, buys only the deficit, and broadcasts the transaction. The agent never holds TRX or thinks about energy.

Any AI agent running in Claude, LangChain, CrewAI, Vertex AI, AutoGen, or BeeAI can send payments and acquire resources on TRON through a single integration with MERX.

Three ways to plug an agent into MERX:

MCP server -- 66 tools for AI agents. Hosted SSE at https://merx.exchange/mcp/sse (zero install) or local stdio via npx merx-mcp. Works with Claude, GPT, Cursor, Windsurf, and any MCP-compatible client.
Claude Code plugin -- one-line install for Claude Code. Auto-registers the MCP server, ships 6 slash commands and a tron-agent-engineer sub-agent. See Hovsteder/merx-claude-plugin.
REST API + SDKs -- direct programmatic access for agents that aren't using MCP. JavaScript (merx-sdk v2.1 on npm), Python (merx-sdk v2.1 on PyPI), or raw HTTP against /api/v1/ (70+ versioned endpoints).

For human users, the web platform at merx.exchange remains available for manual energy trading, dashboard, deposits, and withdrawals -- but the platform is built primarily for agents.

The problem

AI agents will become the dominant transactional users of stablecoins, and TRON -- home to USDD, $86B+ USDT, USDC, and the dominant chain for retail USDT in Southeast Asia, Africa, and Latin America -- is already the largest USDT-native network in the world.

But TRON has no infrastructure designed for agents:

No agent-native payment service. Existing TRON wallets are built for human users with mouse clicks and seed-phrase backups, not for autonomous programs that need to register addresses, send TRC-20s, watch for incoming payments, and create invoices via REST.
Energy and bandwidth are a UX dead-end. Every smart contract call on TRON requires energy. Without energy, TRX tokens burn as fees -- a single USDT transfer burns 3-13 TRX (~$1-4) for cold receivers. Renting energy from a provider drops the cost to ~$0.10 -- a 94% reduction -- but every provider has a different price, different API, different duration tiers, and different failure modes. No agent can be expected to manage that.
No x402 facilitator on TRON before MERX. The x402 protocol has already processed $43.57M in agent-to-agent payments on Base, Solana, Stellar, and Ethereum. TRON was completely absent from the coinbase/x402 ecosystem registry until MERX. Agents that wanted to pay for TRON-hosted APIs in USDT had no standardized way to do it.
Three agent protocols, zero TRON integrations. MCP (Anthropic), A2A (Google), and ACP (BeeAI) are the three major agent communication protocols. Until MERX, none of them had a deployed, production-grade TRON server. AI agents in Claude, Vertex AI, or BeeAI literally could not see TRON.

MERX builds the missing layer. AI agents call one API, hold zero TRX, and get paid / pay / send / receive in USDT, USDC, or USDD on the world's largest USDT network.

Without MERX	With MERX
Agent has to manage energy + bandwidth manually	`send()` estimates and provisions resources automatically
Agent has to hold TRX as gas	GasFree transfers — agents send stablecoins from zero-TRX wallets
Agent has to integrate every energy provider's API	One MERX API routes to the cheapest of 6 providers
No way to pay for TRON-hosted APIs in USDT	x402 v2 facilitator with full USDT/USDC/USDD support
No A2A/ACP discovery on TRON	Agent Card + Manifest live, 7 skills, 7 capabilities
Agent has to write its own MCP server for TRON	66 tools, 30 prompts, 21 resources, hosted
Address watching means polling RPC	`watch()` with sub-3-second webhook delivery via ZMQ

Platform overview

Component	Description
MCP server	66 tools, 30 prompts, 21 resources for AI agents. Hosted SSE at `https://merx.exchange/mcp/sse` (zero install) or local stdio. SEP-1649 server card. The largest TRON-native MCP server in production.
Claude Code plugin	One-line install: `/plugin marketplace add Hovsteder/merx-claude-plugin`. Auto-registers MCP, 6 slash commands, sub-agent.
Agent Payment Service	`agent.merx.exchange` -- non-custodial REST API. `register`, `send`, `receive`, `watch`, `invoice`, `batch`, `schedule`, `contacts`. USDT live; USDD/USDC next sprint.
x402 v2 Facilitator	`x402.merx.exchange` -- only TRON facilitator in the coinbase/x402 ecosystem registry. Three settlement schemes (`exact`, `exact_permit`, `exact_gasfree`) for USDT, USDC, USDD on TRON mainnet plus USDC on Base.
GasFree Transfer Service	Mainnet controller `TKjJ1r5XYqnLZmLakcP3knis7Lh6gm3qtR` activated 2026-04-08. TIP-712 PermitTransfer for USDT/USDC/USDD. Agents send stablecoins from zero-TRX wallets.
A2A Protocol (Google)	Agent Card at `/.well-known/agent.json`. 7 skills including `compile_policy`. Task-based execution with SSE streaming. Compatible with LangChain, CrewAI, Vertex AI, AutoGen, Mastra.
ACP Protocol (BeeAI)	Manifest at `/.well-known/agent-manifest.json`. 7 capabilities matching A2A skills. Run-based execution with long-polling.
Policy Engine	Natural language → standing orders, powered by Anthropic Claude Sonnet 4. Available as MCP tool, A2A skill, and REST endpoint.
Energy aggregator	Real-time price comparison across 6 active providers (CatFee, Netts, TronSave, iTRX, PowerSun, TEM). Routes orders to cheapest source. Underneath the agent surfaces.
Dedicated TRON RPC node	`rpc.merx.exchange`, sub-5ms read latency, 13.7ms broadcast. Trial 1,000 free requests; paid tiers with energy-spend waiver.
REST API	70+ versioned endpoints under `/api/v1/`. Idempotency-Key on POST. Standard error format.
WebSocket	Real-time TRC-20 transfer stream and price updates at `wss://merx.exchange/ws`.
JavaScript SDK	`merx-sdk` v2.1 -- AgentModule + SwapModule + 4 base modules. TypeScript types included.
Python SDK	`merx-sdk` v2.1 -- same surface in snake_case.
x402 middleware	`merx-x402` v2.0.0 -- one-line Express integration for x402 v2.
Documentation	38+ pages at merx.exchange/docs. API reference, MCP/A2A/ACP guides, x402 integration.

Quick start

Four paths depending on your use case. For AI agents, paths 3 and 4 are the primary surfaces. Path 1 (web) is for human operators; path 2 (REST/SDK) is for direct programmatic integration.

Path 1: Web platform (humans)

Go to merx.exchange. Sign in. Deposit TRX. Manage energy, agent API keys, and balance through the dashboard. No code required.

Path 2: REST API / SDK (programmatic)

Install the JavaScript SDK:

bash

npm install merx-sdk

Use it in your application (replace merx_sk_your_key with your API key from merx.exchange):

typescript

import { MerxClient } from 'merx-sdk'

const merx = new MerxClient({ apiKey: 'merx_sk_your_key' })

// Get current prices from all providers
const prices = await merx.prices.list()
console.log(prices[0])
// { provider: "netts", price_sun: 22, available: 100000000 }

// Buy energy at best price
const order = await merx.orders.create({
  resource_type: 'ENERGY',
  amount: 65000,
  duration_sec: 300,
  target_address: 'TYourAddress...',
})
console.log(order.status)   // "FILLED"
console.log(order.cost_trx) // 1.4311

Python:

python

from merx import MerxClient

merx = MerxClient(api_key="merx_sk_your_key")

prices = merx.prices.list()
order = merx.orders.create(
    resource_type="ENERGY",
    amount=65000,
    duration_sec=300,
    target_address="TYourAddress..."
)

curl (no SDK needed):

bash

# Public -- no auth required
curl https://merx.exchange/api/v1/prices

# Authenticated
curl -X POST https://merx.exchange/api/v1/orders \
  -H "Authorization: Bearer merx_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "resource_type": "ENERGY",
    "amount": 65000,
    "duration_sec": 300,
    "target_address": "TYourAddress..."
  }'

Path 3: Claude Code plugin (one-line install)

If you're using Claude Code, this is the fastest path. The plugin auto-registers the hosted MCP server, ships 6 slash commands, and includes a tron-agent-engineer sub-agent specialized in agentic payment workflows on TRON.

code

/plugin marketplace add Hovsteder/merx-claude-plugin
/plugin install merx@merx

Then run /merx:setup to configure your MERX API key. Available commands:

Command	What it does
`/merx:setup`	First-time setup: API key, connection test, capability tour
`/merx:prices`	Live TRON energy and bandwidth prices across all providers
`/merx:buy-energy`	Buy energy via cheapest provider, delegated to a target address
`/merx:balance`	MERX prepaid balance, recent orders, free-tier usage
`/merx:tx`	Look up a TRON transaction with structured fields
`/merx:send`	Send TRC-20 stablecoin via the agent payment service

Source: github.com/Hovsteder/merx-claude-plugin.

Path 4: MCP for any AI agent (Claude, Cursor, Windsurf, custom)

Hosted (zero install) -- works with Claude.ai, Cursor, Windsurf, and any SSE-compatible MCP client:

json

{
  "mcpServers": {
    "merx": {
      "url": "https://merx.exchange/mcp/sse"
    }
  }
}

22 read-only tools are available immediately: prices, estimation, market analysis, on-chain queries, address lookups. No API key required.

To unlock trading tools, call set_api_key in any conversation:

code

set_api_key("merx_sk_your_key")
-> All 34 authenticated tools unlocked for this session.

To unlock write tools (send TRX, swap tokens), call set_private_key:

code

set_private_key("your_64_char_hex_key")
-> Address derived automatically. All 66 tools available.
-> Key never leaves your machine.

Local (stdio) -- full power with keys set via environment variables:

bash

npm install -g merx

json

{
  "mcpServers": {
    "merx": {
      "command": "npx merx-mcp",
      "env": {
        "MERX_API_KEY": "merx_sk_your_key",
        "TRON_PRIVATE_KEY": "your_private_key"
      }
    }
  }
}

All 66 tools available from the first message.

Additional protocol support

MERX also exposes A2A and ACP for non-MCP orchestrators -- same backend, different discovery surface:

A2A (LangChain, CrewAI, Vertex AI, AutoGen, Mastra): Agent Card at https://merx.exchange/.well-known/agent.json -- 7 skills, SSE streaming
ACP (BeeAI): Manifest at https://merx.exchange/.well-known/agent-manifest.json -- 7 capabilities, run-based execution

Access levels

Configuration	Tools	Capabilities
No keys	22	Prices, estimation, market analysis, on-chain queries, address lookups
+ `MERX_API_KEY`	34	+ Orders, balance, deposits, standing orders, monitors
+ `TRON_PRIVATE_KEY`	66	+ Send TRX/USDT/USDC/USDD, swap tokens, approve contracts, execute intents, agent payments

What sets MERX apart

The only complete agent stack on TRON

MERX is the only TRON project that runs all three major agent protocols as production-grade services: MCP (Anthropic), A2A (Google, 7 skills), and ACP (BeeAI, 7 capabilities). TronLink published a core MCP library (@tronlink/tronlink-mcp-core v0.1.0, March 2026) but it is explicitly a building block, not a hosted service. MERX is the only TRON entry in the coinbase/x402 ecosystem partner registry.

Agent payment service with sub-3-second receive

agent.merx.exchange is non-custodial: agents register their own TRON address and MERX never holds private keys or controls funds. The ZMQ event listener matches incoming TRC-20 transfers (USDT, USDC, USDD, plus any other token in real time) and dispatches webhooks within ~3 seconds of on-chain confirmation. watch() provides persistent 24/7 address monitoring with per-token filtering. invoice() creates payment requests with payment links and automatic detection. batch() sends up to 50 transfers in one call.

x402 v2 facilitator with full TRON stablecoin coverage

x402.merx.exchange implements the standard /verify, /settle, and /supported endpoints, so any x402 client (including the Coinbase CDP reference implementation) interoperates out of the box. Three settlement schemes live on TRON mainnet: exact (direct TRC-20 transfer), exact_permit and exact_gasfree (TIP-712 PermitTransfer through MERX's own GasFreeController contract). USDT, USDC, and USDD all settled on mainnet with verified txids and on-chain commission collection. Among 15 known x402 facilitators, MERX is the only one supporting the full TRON stablecoin set.

GasFree zero-TRX sends

The MERX-deployed GasFreeController contract TKjJ1r5XYqnLZmLakcP3knis7Lh6gm3qtR went live on mainnet 2026-04-08 with three verified mainnet permitTransfer settlements (USDT, USDC, USDD). Agents send stablecoins from wallets that hold zero TRX -- the controller pulls value+fee from a per-user GasFree subaccount and the executor pays the broadcast gas. Single biggest UX barrier for agents on TRON, removed.

Resource-aware transactions

Every write operation (TRC-20 transfer, token swap, contract call) automatically estimates energy AND bandwidth needed, buys the deficit at the best market price across 6 providers, waits for delegation to arrive on-chain, then executes. The agent never burns TRX unnecessarily. Tested on mainnet: a USDT transfer with auto-resources saves up to 94% compared to burning.

Exact energy simulation

Before buying energy for swaps and contract calls, MERX simulates the exact transaction via triggerConstantContract with real parameters. No hardcoded estimates -- the precise energy amount is purchased. For a SunSwap V2 swap, simulation returned 223,354 energy; the on-chain transaction used exactly 223,354.

Natural language Policy Engine

"Keep 500,000 energy on my wallet. Buy when price drops below 55 SUN. Max 200 TRX per week."

The Policy Engine (powered by Anthropic Claude Sonnet 4) parses this instruction, generates structured standing orders with triggers, budget limits, and expiration, previews them for the user, and creates everything with one confirmation. Available through MCP, A2A skill, and REST endpoint. No competitor can replicate this without their own Anthropic integration, standing order infrastructure, and real-time provider price feeds.

Multi-provider energy routing (under the agent surfaces)

All 6 active energy providers are aggregated (CatFee, Netts, TronSave, iTRX, PowerSun, TEM). Orders are routed to the cheapest source automatically. If one provider fails or runs out of capacity, the next cheapest fills the order. Prices cover both energy and bandwidth across every available duration tier.

Standing orders + delegation monitors

Server-side 24/7 automation stored in PostgreSQL. Trigger types: price_below, price_above, schedule (cron), balance_below, delegation_expiry. Persists across restarts. Works when the client is offline. Auto-renew with configurable max price.

Full MCP protocol

The only TRON MCP server using all three MCP primitives: tools (66), prompts (30), and resources (21 -- 14 static + 7 templates). Two transport modes: hosted SSE (zero install) and local stdio (full key management). Three protocol versions supported: 2024-11-05, 2025-03-26, 2025-06-18.

Architecture

Platform overview

graph TB
    User[User / Application / AI Agent]
    Platform[MERX Platform<br>merx.exchange]
    PM[Price Monitor<br>polls every 30s]
    OE[Order Executor<br>routes to cheapest]
    DV[Delegation Verifier<br>confirms on-chain]
    TR[Treasury<br>balance management]
    RPC[TronGrid / GetBlock<br>TRON RPC]
    Providers[Energy Providers<br>all connected]
    TRON[TRON Blockchain]

    User -->|Web / API / SDK / MCP| Platform
    Platform --> PM
    Platform --> OE
    Platform --> DV
    Platform --> TR
    PM -->|Price polling| Providers
    OE -->|Order routing<br>cheapest first| Providers
    DV -->|Verify delegations| RPC
    RPC --> TRON
    Providers -->|Delegate energy<br>+ bandwidth| TRON

    style User fill:#1a1a2e,stroke:#B8963E,color:#F5F0E8
    style Platform fill:#0C0B09,stroke:#B8963E,color:#F5F0E8
    style TRON fill:#141310,stroke:#B8963E,color:#F5F0E8

ASCII diagram (if Mermaid does not render)

code

User / Application / AI Agent
    |
    | Web / REST API / SDK / MCP
    v
+----------------------------------+
|         MERX Platform            |
|         merx.exchange            |
|                                  |
|  +------------+ +-------------+  |
|  |   Price    | |   Order     |  |
|  |  Monitor   | |  Executor   |  |
|  | (every 30s)| | (cheapest)  |  |
|  +------------+ +-------------+  |
|  +------------+ +-------------+  |
|  | Delegation | |  Treasury   |  |
|  |  Verifier  | |  Manager    |  |
|  +------------+ +-------------+  |
+----------------------------------+
    |                    |
    v                    v
TronGrid / GetBlock   Energy Providers
(TRON RPC)            (all connected)
    |                    |
    v                    v
+----------------------------------+
|        TRON Blockchain           |
+----------------------------------+

Key architecture principle: All traffic goes through the MERX platform. Users never need TronGrid API keys. MERX manages all RPC infrastructure, caching, and failover server-side. The only operation that stays on the client: transaction signing with a private key. Private keys never leave the client process.

Resource-aware transaction flow

This sequence diagram shows a real USDT transfer with auto-resource optimization. Numbers are from production testing.

sequenceDiagram
    participant C as Client
    participant M as MERX
    participant P as Providers
    participant T as TRON

    C->>M: POST /orders or transfer_trc20(USDT, 100, TAddr)
    M->>M: POST /estimate (trc20_transfer)
    Note over M: energy: 7,896 / bandwidth: 345
    M->>M: GET /chain/resources/TSender
    Note over M: energy: 0 / bandwidth: 0 / free BW: 600
    Note over M: Energy deficit: 7,896 (round up to 65,000 min)<br>Bandwidth: 345 < 1,500 min order, skip
    M->>P: Route order: ENERGY, 65,000, 300s
    P-->>M: FILLED at 22 SUN (1.43 TRX)
    Note over M: Poll every 2s until delegation arrives
    M->>T: Verify delegation on sender address
    T-->>M: energy: 65,050 available
    Note over M: Sign TX (client-side if MCP, server-side if API)
    M->>T: Broadcast signed TX
    T-->>M: TX confirmed
    M-->>C: USDT sent. Cost: 1.43 TRX.<br>Burn alternative: 3.66 TRX. Savings: 87.6%

ASCII diagram (if Mermaid does not render)

code

Client                  MERX                    Providers               TRON
  |                       |                       |                      |
  | order / transfer      |                       |                      |
  |---------------------->|                       |                      |
  |                       | estimate energy+BW    |                      |
  |                       | energy: 7,896         |                      |
  |                       | bandwidth: 345        |                      |
  |                       |                       |                      |
  |                       | check sender resources|                      |
  |                       | energy: 0, BW: 0      |                      |
  |                       |                       |                      |
  |                       | [deficit: 7,896 -> round up to 65,000]      |
  |                       | [BW: 345 < 1,500 min -> skip, burn ~0.3 TRX]|
  |                       |                       |                      |
  |                       | route to cheapest     |                      |
  |                       |---------------------->|                      |
  |                       |   FILLED 22 SUN       |                      |
  |                       |   1.43 TRX            |                      |
  |                       |<----------------------|                      |
  |                       |                       |                      |
  |                       | [poll until delegation arrives]              |
  |                       |                       |                      |
  |                       | verify delegation     |--------------------->|
  |                       |   energy: 65,050      |<---------------------|
  |                       |                       |                      |
  |                       | [sign + broadcast]    |                      |
  |                       |---------------------->|--------------------->|
  |                       |                       |   TX confirmed       |
  |                       |<----------------------|<---------------------|
  |                       |                       |                      |
  |   USDT sent           |                       |                      |
  |   Cost: 1.43 TRX      |                       |                      |
  |   Burn alt: 3.66 TRX  |                       |                      |
  |   Savings: 87.6%      |                       |                      |
  |<----------------------|                       |                      |

Resource purchase rules

Rule	Details
Energy deficit > 0	Round up to minimum 65,000 units. Cheaper to buy minimum than to burn even small deficits.
Bandwidth deficit < 1,500	Skip purchase, let network burn ~0.3 TRX. Cheaper than minimum bandwidth order.
After energy purchase	Poll `check_address_resources` every 2 seconds until delegation arrives on-chain. Never broadcast TX before delegation is confirmed.
DEX swaps	Simulate exact energy via `triggerConstantContract` with real swap parameters. No hardcoded estimates.

API overview

Base URL: https://merx.exchange/api/v1

All endpoints are versioned. Errors follow a standard format: { "error": { "code": "...", "message": "...", "details": { ... } } }. Idempotency-Key header supported on POST /orders and POST /withdraw.

Public endpoints (no authentication)

Method	Endpoint	Description
GET	`/prices`	Current energy and bandwidth prices from all providers
GET	`/prices/best`	Cheapest provider for given resource and amount
GET	`/prices/history`	Historical price snapshots by provider and period
GET	`/prices/stats`	Price statistics: min, max, average, percentiles
GET	`/prices/analysis`	Market analysis with trends and recommendations
GET	`/orders/preview`	Preview order cost without creating it
POST	`/estimate`	Estimate energy and bandwidth for any transaction type
GET	`/chain/account/:address`	On-chain account info
GET	`/chain/resources/:address`	Energy, bandwidth, and free BW for any address
GET	`/chain/transaction/:txid`	Transaction details by ID
GET	`/chain/block/:number`	Block info by number or latest
GET	`/chain/parameters`	TRON network parameters

Authenticated endpoints (API key required)

Method	Endpoint	Description
POST	`/orders`	Create order -- routed to cheapest provider
GET	`/orders`	List orders with optional status filter
GET	`/orders/:id`	Order details with fills, TX hashes, verification
GET	`/balance`	MERX account balance (TRX, USDT, locked)
GET	`/deposit/info`	Deposit address and memo
POST	`/withdraw`	Withdraw TRX to external address
GET	`/history`	Account transaction history
GET	`/history/summary`	History summary with totals
POST	`/keys`	Create new API key
GET	`/keys`	List API keys
DELETE	`/keys/:id`	Revoke API key
POST	`/webhooks`	Register webhook endpoint
GET	`/webhooks`	List registered webhooks
DELETE	`/webhooks/:id`	Remove webhook
POST	`/ensure`	Ensure minimum resources on an address
POST	`/standing-orders`	Create server-side standing order
GET	`/standing-orders`	List standing orders
POST	`/monitors`	Create delegation or balance monitor
GET	`/monitors`	List monitors

x402 endpoints (zero registration)

Method	Endpoint	Description
POST	`/x402/invoice`	Create payment invoice
POST	`/x402/verify`	Verify invoice payment

Full API reference: merx.exchange/docs/api

MCP server

MERX provides a full MCP (Model Context Protocol) server for AI agents. 66 tools across 18 categories, 30 pre-built prompts, and 21 live data resources.

Note: the tool catalog table below was last fully audited at 52 tools. Twelve newer tools (agent payment service, swap module, advanced standing orders) are documented at merx.exchange/docs/tools/mcp-server. The canonical count is 64, served by the live MCP server.

Tool categories

Category	Count	Auth	Description
Price Intelligence	5	--	Real-time prices from all providers, market analysis, trends, history
Resource Estimation	2	--	Estimate energy + bandwidth for any transaction type
Resource Trading	4	API key	Buy energy/bandwidth at best price, ensure resources on any address
Account Management	3	API key	Balance, deposit info, transaction history
Agent Convenience	4	--	Explain concepts, suggest durations, calculate savings, list providers
On-chain Queries	5	--	Account info, TRX/TRC20 balances, transaction lookup, blocks
Token Operations	4	Private key	Send TRX, transfer TRC20, approve tokens -- all resource-aware
Smart Contracts	3	Mixed	Read contract state, estimate call cost, execute with auto-resources
Network Utilities	5	--	Chain parameters, address tools, TRX price, on-chain history
DEX Swaps	3	Private key	SunSwap V2 quotes, execution with exact energy simulation
Onboarding	2	--	Create account + login, no browser needed
Payments	4	Mixed	Self-deposit, auto-deposit config, x402 pay-per-use
Intent Execution	2	Mixed	Multi-step plans: simulate or execute complex sequences
Standing Orders	4	API key	Server-side 24/7 automation: price triggers, cron, monitors
Session Management	2	--	Set API key and private key for current session
Total	52

Prompts (30)

Pre-built conversation templates available in Claude Desktop prompt picker and via prompts/get in any MCP client.

Group	Prompts	Examples
Market (5)	buy-energy, buy-bandwidth, ensure-resources, market-analysis, compare-providers	"Buy energy at best market price"
Transactions (5)	send-usdt, send-trx, send-token, multi-transfer, explain-transaction	"Send USDT with auto resource optimization"
Wallet (4)	check-wallet, audit-spending, monitor-delegations, optimize-wallet	"Full wallet overview with balances and delegations"
DEX (3)	swap-tokens, check-token, price-check	"Swap tokens via SunSwap"
Planning (3)	estimate-costs, budget-plan, stake-vs-rent	"Plan energy budget for a period"
Developer (2)	integrate-merx, setup-mcp	"How to integrate MERX API"
Onboarding (2)	onboard, fund-account	"Create account and get started"
Payments (2)	setup-auto-funding, buy-without-account	"x402 zero-registration purchase"
Simulation (2)	simulate-plan, execute-plan	"Simulate a multi-step plan"
Monitoring (2)	setup-standing-order, auto-renew-delegations	"Set up auto-renewal for delegations"

Resources (21)

14 static resources + 7 URI templates. Attach to conversations as context or subscribe for real-time updates.

Resource	URI	Updates
Energy prices	`merx://prices/energy`	Every 30s
Bandwidth prices	`merx://prices/bandwidth`	Every 30s
Best price	`merx://prices/best`	Every 30s
Market analysis	`merx://market/analysis`	Every 5m
Provider list	`merx://market/providers`	Every 30s
Provider status	`merx://market/providers/status`	Every 30s
Account balance	`merx://account/balance`	On change
Recent orders	`merx://account/orders/recent`	On change
Account stats	`merx://account/stats`	Every 5m
Auto-deposit config	`merx://account/auto-deposit`	On change
Network parameters	`merx://network/parameters`	Every 1h
TRX price	`merx://network/trx-price`	Every 1m
Token reference	`merx://reference/tokens`	Static
Standing orders	`merx://standing-orders/active`	On change

URI Templates:

Template	Description
`merx://address/{address}/overview`	Full address state: TRX, tokens, energy, bandwidth
`merx://address/{address}/resources`	Energy + bandwidth with free BW tracking
`merx://address/{address}/transactions`	Recent transactions with type and amounts
`merx://address/{address}/delegations`	Active delegations with expiry times
`merx://token/{token}/info`	Token metadata + price + transfer energy cost
`merx://order/{order_id}/status`	Order details with fills and cost breakdown
`merx://standing-order/{id}/status`	Standing order trigger state and executions

Example conversations

Check prices and buy energy:

code

User: What is the cheapest energy right now?
Agent: [calls get_prices] Cheapest energy is 22 SUN from Netts (5-minute
       delegation). For 65,000 energy, that is 1.43 TRX.
User: Buy it for TLyqz...
Agent: [calls create_order] Done. 65,050 energy delegated via Netts.
       Cost: 1.43 TRX. TX: 27ab0019... (verified on-chain).

Resource-aware USDT transfer:

code

User: Send 100 USDT to TAddr.
Agent: [calls transfer_trc20] MERX estimated 7,896 energy needed,
       bought 65,000 at 22 SUN, waited for delegation, signed and
       broadcast. USDT sent. Cost: 1.43 TRX instead of 3.66 TRX.
       Savings: 87.6%.

Market analysis:

code

User: Is now a good time to buy energy?
Agent: [calls analyze_prices] Energy is at 22 SUN -- the 1st percentile
       of the last 7 days. 64% below the weekly average of 62 SUN.
       Trend: falling. Recommendation: good time to buy.

Full tool reference

All 66 tools with auth requirements. For input schemas and output examples, see docs/TOOLS.md.

Price Intelligence

#	Tool	Description	Auth
1	`get_prices`	Current energy and bandwidth prices from all providers	--
2	`get_best_price`	Cheapest provider for given resource and amount	--
3	`analyze_prices`	Market analysis with trends, percentile, and recommendation	--
4	`get_price_history`	Historical price snapshots by provider, resource, and period	--
5	`compare_providers`	Side-by-side provider comparison with all duration tiers	--

Resource Estimation

#	Tool	Description	Auth
6	`estimate_transaction_cost`	Estimate energy + bandwidth for TRX/TRC20/custom operations	--
7	`check_address_resources`	Energy, bandwidth, free BW, and TRX balance for any address	--

Resource Trading

#	Tool	Description	Auth
8	`create_order`	Buy energy or bandwidth, routed to cheapest provider	API key
9	`get_order`	Order details with fills, TX hashes, and verification status	API key
10	`list_orders`	List orders with optional status filter	API key
11	`ensure_resources`	Declarative: ensure minimum energy/bandwidth on an address	API key

Account Management

#	Tool	Description	Auth
12	`get_balance`	MERX account balance (TRX, USDT, locked)	API key
13	`get_deposit_info`	MERX deposit address and memo	API key
14	`get_transaction_history`	MERX account order history (7D/30D/90D)	API key

Agent Convenience

#	Tool	Description	Auth
15	`explain_concept`	Explain TRON concepts: energy, bandwidth, staking, delegation, sun_units	--
16	`suggest_duration`	Recommend rental duration based on use case and TX count	--
17	`calculate_savings`	Calculate savings from renting vs burning for N transactions	--
18	`list_providers`	All providers with types, durations, and availability	--

On-chain Queries

#	Tool	Description	Auth
19	`get_account_info`	Full on-chain account: TRX, energy, bandwidth, limits	--
20	`get_trx_balance`	Quick TRX balance for any address	--
21	`get_trc20_balance`	TRC-20 token balance (supports symbol or contract address)	--
22	`get_transaction`	Look up transaction by ID with status, energy, bandwidth used	--
23	`get_block`	Block info by number (or latest)	--

Token Operations

#	Tool	Description	Auth
24	`transfer_trx`	Send TRX with auto bandwidth optimization	Private key
25	`transfer_trc20`	Transfer TRC-20 tokens with auto energy + bandwidth	Private key
26	`approve_trc20`	Approve TRC-20 spending allowance with auto energy	Private key
27	`get_token_info`	Token metadata: name, symbol, decimals, total supply	--

Smart Contracts

#	Tool	Description	Auth
28	`read_contract`	Call view/pure contract functions (no gas, no signing)	--
29	`estimate_contract_call`	Estimate energy + bandwidth for a contract call	--
30	`call_contract`	Execute state-changing contract function with auto resources	Private key

Network Utilities

#	Tool	Description	Auth
31	`get_chain_parameters`	TRON network parameters with MERX price comparison	--
32	`convert_address`	Convert between base58 (T...) and hex (41...) formats	--
33	`get_trx_price`	Current TRX price from CoinGecko	--
34	`validate_address`	Validate TRON address format and check on-chain status	--
35	`search_transaction_history`	On-chain transaction history for any address	--

DEX Swaps

#	Tool	Description	Auth
36	`get_swap_quote`	Real SunSwap V2 quote with expected output and slippage	--
37	`execute_swap`	Execute SunSwap swap with exact energy simulation	Private key
38	`get_token_price`	Token price via SunSwap pools + CoinGecko USD rate	--

Onboarding

#	Tool	Description	Auth
39	`create_account`	Create MERX account and get API key	--
40	`login`	Log in to existing MERX account	--

Payments

#	Tool	Description	Auth
41	`deposit_trx`	Deposit TRX to MERX from wallet (signs TX with memo)	API key + Private key
42	`enable_auto_deposit`	Configure auto-deposit when balance drops below threshold	API key
43	`pay_invoice`	Pay an existing x402 invoice	Private key
44	`create_paid_order`	x402 zero-registration order: invoice, pay, verify, order	Private key

Intent Execution

#	Tool	Description	Auth
45	`execute_intent`	Execute multi-step plan with resource optimization	API key
46	`simulate`	Simulate multi-step plan without executing	--

Standing Orders and Monitors

#	Tool	Description	Auth
47	`create_standing_order`	Create server-side standing order with trigger + action	API key
48	`list_standing_orders`	List standing orders with status filter	API key
49	`create_monitor`	Create persistent monitor (delegation, balance, price)	API key
50	`list_monitors`	List monitors with status filter	API key

Session Management

#	Tool	Description	Auth
51	`set_api_key`	Set MERX API key for this session	--
55	`set_private_key`	Set TRON private key for this session (address auto-derived)	--

SDKs

JavaScript / TypeScript

bash

npm install merx-sdk

typescript

import { MerxClient } from 'merx-sdk'

const merx = new MerxClient({ apiKey: 'merx_sk_your_key' })

// 4 modules: prices, orders, balance, webhooks
const prices   = await merx.prices.list()
const best     = await merx.prices.best({ resource: 'ENERGY' })
const order    = await merx.orders.create({ ... })
const status   = await merx.orders.get(order.id)
const balance  = await merx.balance.get()
const webhooks = await merx.webhooks.list()

Property	Value
Package	`merx-sdk`
Modules	`prices`, `orders`, `balance`, `webhooks`
Methods	16
TypeScript	Full type definitions included
Dependencies	Zero
Node.js	18+

Python

bash

pip install merx-sdk

python

from merx import MerxClient

merx = MerxClient(api_key="merx_sk_your_key")

# Same 4 modules, snake_case
prices  = merx.prices.list()
best    = merx.prices.best(resource="ENERGY")
order   = merx.orders.create(resource_type="ENERGY", amount=65000, ...)
status  = merx.orders.get(order.id)
balance = merx.balance.get()

Property	Value
Package	`merx-sdk`
Modules	`prices`, `orders`, `balance`, `webhooks`
Methods	16
Type hints	Full type annotations
Dependencies	Zero
Python	3.11+

REST API

No SDK required. All endpoints accept JSON and return JSON.

bash

# Get prices (public, no auth)
curl https://merx.exchange/api/v1/prices

# Get best price for energy
curl https://merx.exchange/api/v1/prices/best?resource=ENERGY

# Create order (authenticated)
curl -X POST https://merx.exchange/api/v1/orders \
  -H "Authorization: Bearer merx_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"resource_type":"ENERGY","amount":65000,"duration_sec":300,"target_address":"TAddr..."}'

# Check balance
curl https://merx.exchange/api/v1/balance \
  -H "Authorization: Bearer merx_sk_your_key"

Real-time data

WebSocket

Connect to wss://merx.exchange/ws for real-time price updates.

javascript

const ws = new WebSocket('wss://merx.exchange/ws')

ws.onopen = () => {
  // Subscribe to all energy price updates
  ws.send(JSON.stringify({ type: 'subscribe', channel: 'prices', resource: 'ENERGY' }))
}

ws.onmessage = (event) => {
  const data = JSON.parse(event.data)
  // { provider: "netts", resource: "ENERGY", price_sun: 22, available: 100000000, ... }
}

Property	Value
Endpoint	`wss://merx.exchange/ws`
Channels	`prices`, `orders`, `balance`
Update frequency	Every 30 seconds for prices
Heartbeat	Every 30 seconds
Reconnect	Client-side with exponential backoff recommended

Webhooks

bash

curl -X POST https://merx.exchange/api/v1/webhooks \
  -H "Authorization: Bearer merx_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://your-app.com/webhook","events":["order.filled","deposit.received"]}'

Event	Fired when
`order.filled`	Energy or bandwidth order has been filled by a provider
`order.failed`	Order failed after all provider attempts exhausted
`deposit.received`	TRX deposit confirmed and credited to balance
`withdrawal.completed`	TRX withdrawal broadcast and confirmed on-chain

Security: Every webhook request includes an X-Merx-Signature header containing an HMAC-SHA256 signature computed with your webhook secret. Verify this signature before processing. Failed deliveries are retried with exponential backoff.

Payment methods

MERX supports three ways to pay for energy and bandwidth.

1. Pre-funded MERX balance

Deposit TRX to your MERX account via the dashboard at merx.exchange or via the API. Trade directly from your balance. Best for high-volume users and teams.

bash

# Check balance
curl https://merx.exchange/api/v1/balance \
  -H "Authorization: Bearer merx_sk_your_key"

# Response
# { "available_trx": 45.20, "locked_trx": 1.43, "total_trx": 46.63 }

2. Self-deposit from agent wallet

The agent deposits TRX to MERX from its own wallet using the deposit_trx tool or API. The tool builds a TRX transfer with the correct memo, signs it locally, and broadcasts. Balance is credited in 1-2 minutes.

code

deposit_trx(amount: 10)
-> TX: 4bc60854f828...8ddcd509
-> 10 TRX deposited. Will be credited to your MERX balance shortly.

3. x402 pay-per-use

No account needed. No pre-deposit. Create an invoice, pay with TRX from any wallet, and receive energy delegation directly. Complete flow in one API call or one tool call via create_paid_order.

code

create_paid_order(amount: 65000, duration_sec: 300,
  resource_type: "ENERGY", target_address: "THT49...")
-> Invoice: inv_f41ffc2f...
-> Payment TX: 53236a5a...
-> Cost: 1.43 TRX
-> Status: PENDING -> FILLED
-> 65,050 energy delegated to THT49...

Method	Setup required	Best for	Min deposit
Pre-funded balance	Account + dashboard deposit	High-volume users, teams	Any amount
Self-deposit (`deposit_trx`)	API key + private key	Autonomous agents	Any amount
x402 (`create_paid_order`)	Private key only	One-off purchases, no-account agents	Per-order

See docs/PAYMENT-METHODS.md for detailed flow diagrams.

Standing orders and monitors

Standing orders

Server-side 24/7 automation stored in PostgreSQL. Persists across restarts. Works when the client is offline.

Trigger types:

Trigger	Description	Example
`price_below`	Fire when best price drops below threshold	Buy 65,000 energy when price < 20 SUN
`price_above`	Fire when best price exceeds threshold	Alert when energy exceeds 50 SUN
`schedule`	Cron-based schedule	Buy energy every day at 03:00 UTC
`balance_below`	Fire when MERX balance drops below threshold	Auto-deposit 50 TRX when balance < 10 TRX

Action types:

Action	Description
`buy_resource`	Buy specified amount of energy or bandwidth
`ensure_resources`	Ensure minimum resources on target address
`notify_only`	Send notification via webhook

Example:

code

create_standing_order(
  trigger: { type: "price_below", resource: "ENERGY", threshold_sun: 20 },
  action: { type: "buy_resource", amount: 65000, duration_sec: 300 },
  target_address: "TLyqz...",
  max_executions: 10,
  budget_trx: 15
)

-> Standing Order: so_a1b2c3d4
-> Status: ACTIVE
-> Trigger: ENERGY price < 20 SUN
-> Action: Buy 65,000 energy (5m)
-> Budget: 15 TRX (10 executions max)

Delegation monitors

Watch delegations and resources on any address. Alert before expiry. Auto-renew with configurable max price.

Monitor type	Description	Example
`delegation_expiry`	Alert before energy/bandwidth delegation expires	Alert 5 minutes before expiry, auto-renew at max 30 SUN
`balance_threshold`	Alert when TRX balance drops below threshold	Alert when balance < 5 TRX
`price_alert`	Alert on price movements	Alert when energy price drops below 20 SUN

Example:

code

create_monitor(
  type: "delegation_expiry",
  address: "TLyqz...",
  resource: "ENERGY",
  alert_before_sec: 300,
  auto_renew: true,
  max_price_sun: 30
)

-> Monitor: mon_e5f6g7h8
-> Status: ACTIVE
-> Type: delegation_expiry
-> Alert: 5 minutes before expiry
-> Auto-renew: Yes (max 30 SUN)

Savings calculator

Energy is the expensive resource on TRON. These numbers show the cost difference between burning TRX (no energy) and renting energy through MERX.

Resource	Purpose	Free daily	Without it
Energy	Smart contract execution (USDT transfers, swaps, approvals)	0 (must stake or rent)	TRX burned at network rate
Bandwidth	Transaction serialization (every TX needs some)	600 bytes/day	TRX burned at network rate

Cost comparison

Scenario	Burn cost (no energy)	Rental cost (MERX)	Savings
1 USDT transfer	3-13 TRX	1.43 TRX	56-89%
10 USDT transfers	30-130 TRX	14.30 TRX	52-89%
100 USDT transfers/day	300-1,300 TRX	143 TRX	52-89%
SunSwap swap (small)	~50 TRX	~4.91 TRX	~90%
Contract call (simple)	~1 TRX	~0.09 TRX	~91%

Numbers assume the cheapest available provider at time of order. Actual burn cost varies by recipient address state (whether it has held the token before).

How it works

1 TRX = 1,000,000 SUN. Energy is priced in SUN per unit. A USDT transfer needs approximately 65,000 energy units. At 22 SUN per unit, that is 65,000 x 22 = 1,430,000 SUN = 1.43 TRX. Without energy, the network burns 3-13 TRX from the sender depending on the recipient's account state.

Error handling

All errors follow a standard format across API, SDKs, and MCP:

json

{
  "error": {
    "code": "INSUFFICIENT_BALANCE",
    "message": "MERX balance too low. Need 1.43 TRX, have 0.50 TRX.",
    "details": {
      "required_trx": 1.43,
      "available_trx": 0.50
    }
  }
}

Common error codes

Code	Description	Resolution
`INSUFFICIENT_BALANCE`	MERX account balance too low	Deposit TRX via dashboard or `deposit_trx`
`PROVIDER_UNAVAILABLE`	All providers failed for this order	Try again later or increase max price
`INVALID_ADDRESS`	TRON address format invalid	Check address starts with T and is 34 characters
`DELEGATION_TIMEOUT`	Energy delegation did not arrive within timeout	Check order status with `get_order`
`SIMULATION_FAILED`	Contract call simulation failed	Check contract address and function parameters
`PRIVATE_KEY_REQUIRED`	Operation requires TRON private key	Set `TRON_PRIVATE_KEY` env var or call `set_private_key`
`API_KEY_REQUIRED`	Operation requires MERX API key	Set `MERX_API_KEY` env var or call `set_api_key`
`ORDER_MIN_AMOUNT`	Amount below minimum order size	Energy minimum: 65,000. Bandwidth minimum: 1,500

Security

Private key handling

Private keys are set via environment variable (TRON_PRIVATE_KEY) or the set_private_key tool in-session.
Keys never leave the client process. All transaction signing happens locally.
The MERX API never receives private keys.
The set_private_key tool derives the TRON address automatically -- the user only provides the 64-character hex key.

API key handling

API keys authenticate with the MERX API for trading operations.
Keys can be set via environment variable (MERX_API_KEY) or the set_api_key tool in-session.
Create an account and get an API key without leaving the conversation using the create_account tool.

What MERX can and cannot do

With private key	Without private key
Sign and broadcast transactions	Read-only operations only
Send TRX and TRC-20 tokens	Check prices and balances
Execute swaps	Get swap quotes
Approve contracts	Estimate costs
Deposit TRX to MERX	View market data

Tested on mainnet

Every capability was tested in production on TRON mainnet. These are not simulations -- every TX hash is verifiable on TronScan.

Verified transactions

Category	Operation	TX Hash	Status	Details
Token Operations	`transfer_trx`	`b22813a813c3...990e7955`	SUCCESS	0.1 TRX sent, 267 bandwidth consumed
Payments	`deposit_trx`	`4bc60854f828...8ddcd509`	SUCCESS	10 TRX deposited to MERX with memo, credited to balance
Token Operations	`approve_trc20`	`56fc87f319b9...0bf5ffbb`	SUCCESS	USDT approval, 99,764 energy consumed
Smart Contracts	`call_contract`	`fc55aee3dc50...4bb5c1bf`	SUCCESS	name() call on contract, 4,098 energy consumed
DEX Swaps	`execute_swap`	`61424b1e89a0...d066d21577`	SUCCESS	0.1 TRX -> 0.032 USDT via SunSwap V2, 223,354 energy (exactly as simulated)
Resource Trading	`create_order`	`8adac3b8a859...4e69e4ca`	FILLED	65,050 energy via Netts at 22 SUN, 1.43 TRX
Payments	`create_paid_order`	`53236a5aeba0...984dec7b`	SUCCESS	x402 flow: 1.43 TRX invoice paid, 65,050 energy delegated

Key findings from mainnet testing

Metric	Value
USDT transfer energy (typical)	65,000 units
USDT transfer cost (rented energy)	1.43 TRX
USDT transfer cost (burned)	3-13 TRX
Maximum savings observed	94%
SunSwap swap energy (0.1 TRX -> USDT)	223,354 units (exact simulation match)
SunSwap swap output	0.032094 USDT for 0.1 TRX
x402 payment flow	Invoice -> pay -> verify -> order -> fill -> delegate (one call)
Energy delegation confirmation	2-6 seconds after order fill

Comparison with alternatives

Factual comparison based on publicly available information.

Feature	MERX	Sun Protocol	Netts MCP	TronLink MCP	PowerSun MCP
MCP Tools	55	~20	~10	27	27
MCP Prompts	30	0	0	0	0
MCP Resources	21	0	0	0	0
REST API	70+ endpoints	No	No	No	No
JavaScript SDK	Yes	No	No	No	No
Python SDK	Yes	No	No	No	No
WebSocket	Yes	No	No	No	No
Web exchange	Yes	No	No	No	No
Transport	stdio + SSE	stdio	stdio	stdio	SSE
Energy providers	All connected	0	1	0	1
Bandwidth support	Yes	No	No	No	No
Auto resource purchase	Energy + BW	No	No	No	Energy only
Exact energy simulation	Yes	No	No	No	No
Intent execution	Yes	No	No	No	No
Standing orders (24/7)	Yes	No	No	No	No
Delegation monitors	Yes	No	No	No	No
x402 pay-per-use	Yes	No	No	No	No
DEX swaps	Yes	No	No	No	Yes
Zero install option	Yes (SSE)	No	No	No	Yes (SSE)
Private key required	Optional	Yes	Yes	Yes	No
Webhooks	Yes	No	No	No	No
Tested on mainnet	7 TX verified	Unknown	Unknown	Unknown	Unknown

MERX covers resource economics, transaction optimization, and general blockchain operations. Other servers focus on one area.

Documentation


Platform	merx.exchange
Documentation	merx.exchange/docs
API Reference	merx.exchange/docs/api
MCP Tools	docs/TOOLS.md
MCP Prompts	docs/PROMPTS.md
MCP Resources	docs/RESOURCES.md
Configuration	docs/CONFIGURATION.md
Examples	docs/EXAMPLES.md
Comparison	docs/COMPARISON.md
Intent Guide	docs/INTENT-GUIDE.md
Standing Orders	docs/STANDING-ORDERS-GUIDE.md
Payment Methods	docs/PAYMENT-METHODS.md
Architecture	docs/ARCHITECTURE.md
Changelog	docs/CHANGELOG.md

License

MIT. See LICENSE.

Install

Tools (66)

get_pricesget_best_priceanalyze_pricesget_price_historycompare_providersestimate_transaction_costcheck_address_resourcescreate_order

Configuration

Environment variables

MERX_API_KEYsecret

API key from merx.exchange. Unlocks trading, balance, standing orders, and monitors.

TRON_PRIVATE_KEYsecret

TRON wallet private key for signing transactions. Never sent to any server. Enables transfers, swaps, and contract calls.

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "mcp": {
      "command": "npx",
      "args": [
        "-y",
        "merx-mcp@1.0.5"
      ],
      "env": {
        "MERX_API_KEY": "<YOUR_MERX_API_KEY>",
        "TRON_PRIVATE_KEY": "<YOUR_TRON_PRIVATE_KEY>"
      }
    }
  }
}

exchange.merx/mcp — Model Context Protocol (MCP) Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

get_prices

get_best_price

analyze_prices

get_price_history

compare_providers

estimate_transaction_cost

check_address_resources

create_order

get_order

list_orders

ensure_resources

wait_for_delegation

get_balance

get_deposit_info

get_transaction_history

explain_concept

suggest_duration

calculate_savings

list_providers

get_account_info

get_trx_balance

get_trc20_balance

get_transaction

get_block

get_chain_parameters

convert_address

get_trx_price

validate_address

search_transaction_history

transfer_trx

transfer_trc20

approve_trc20

get_token_info

read_contract

estimate_contract_call

call_contract

get_contract_info

get_swap_quote

execute_swap

get_token_price

create_account

login

set_api_key

set_private_key

deposit_trx

enable_auto_deposit

pay_invoice

create_paid_order

execute_intent

simulate

create_standing_order

list_standing_orders

get_standing_order

cancel_standing_order

create_monitor

list_monitors

cancel_monitor

withdraw

compile_policy

resource_broadcast

register_agent

request_payment

lookup_invoice

create_invoice

watch_address

agent_status

MERX

https://MERX.exchange

Table of contents

What is MERX

The problem

Platform overview

Quick start

Path 1: Web platform (humans)