# Merx Mcp

> The complete TRON infrastructure layer for AI agents. 55 tools, 30 prompts, 21 resources. Buy energy, send USDT, swap tokens, simulate transactions — all with automatic resource optimization. One config line.

- **Type:** MCP server
- **Install:** `agentstack add mcp-hovsteder-merx-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Hovsteder](https://agentstack.voostack.com/s/hovsteder)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 1.0.2
- **License:** MIT
- **Upstream author:** [Hovsteder](https://github.com/Hovsteder)
- **Source:** https://github.com/Hovsteder/merx-mcp
- **Website:** https://merx.exchange

## Install

```sh
agentstack add mcp-hovsteder-merx-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# MERX
### https://MERX.exchange

**TRON infrastructure for AI agents.**

[](https://smithery.ai/servers/powersun/merx)
[](https://www.npmjs.com/package/merx-mcp)
[](LICENSE)

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

[Documentation](https://merx.exchange/docs) | [API Reference](https://merx.exchange/docs/api) | [MCP Server](#mcp-server)

---

## Table of contents

- [What is MERX](#what-is-merx) — TRON infrastructure for AI agents
- [The problem](#the-problem) — why TRON had no agent layer until MERX
- [Platform overview](#platform-overview) — MCP, agent payment service, x402, GasFree, energy aggregator
- [Quick start](#quick-start) — 4 paths (web, REST/SDK, Claude Code plugin, MCP)
- [What sets MERX apart](#what-sets-merx-apart) — only complete agent stack on TRON
- [Architecture](#architecture)
- [API overview](#api-overview)
- [MCP server](#mcp-server)
- [SDKs](#sdks)
- [Real-time data](#real-time-data)
- [Payment methods](#payment-methods)
- [Standing orders and monitors](#standing-orders-and-monitors)
- [Savings calculator](#savings-calculator)
- [Error handling](#error-handling)
- [Security](#security)
- [Tested on mainnet](#tested-on-mainnet)
- [Comparison with alternatives](#comparison-with-alternatives)
- [Documentation](#documentation)
- [License](#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](https://github.com/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](https://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](https://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](https://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](https://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.

```
/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](https://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:

```
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`:

```
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](https://merx.exchange/.well-known/agent.json) -- 7 skills, SSE streaming
- **ACP** (BeeAI): Manifest at
  [https://merx.exchange/.well-known/agent-manifest.json](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](https://github.com/coinbase/x402/tree/main/partners-data).

### 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,

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Hovsteder](https://github.com/Hovsteder)
- **Source:** [Hovsteder/merx-mcp](https://github.com/Hovsteder/merx-mcp)
- **License:** MIT
- **Homepage:** https://merx.exchange

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v1.0.2 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **1.0.2** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-hovsteder-merx-mcp
- Seller: https://agentstack.voostack.com/s/hovsteder
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.