MERX

MERX

https://MERX.exchange

The first TRON resource exchange.

One platform. Every energy and bandwidth provider. Best price automatically.

Documentation | API Reference | MCP Server

Table of contents

• What is MERX
• The problem
• Platform overview
• Quick start
• What sets MERX apart
• 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 a TRON resource exchange that aggregates every major energy and bandwidthprovider into a single platform. It monitors prices across all connected providersevery 30 seconds, compares every duration tier, and routes orders to the cheapestavailable source automatically. If a provider fails or runs out of capacity, thenext cheapest fills the order. No manual comparison. No provider lock-in.

The platform handles the full resource lifecycle: price discovery, order routing,delegation verification, and transaction execution. All amounts are tracked in SUNinternally (1 TRX = 1,000,000 SUN) for precision.

Three ways to use MERX:

• Web platform at merx.exchange -- trade energy andbandwidth through the dashboard, manage deposits and withdrawals, view orderhistory, and monitor delegations.

• REST API + SDKs -- integrate TRON resource management into any applicationwith JavaScript, Python, or raw HTTP. 46 endpoints covering prices, orders,balance, deposits, withdrawals, webhooks, and API key management.

• MCP server -- give AI agents full TRON access through 52 tools, 30 prompts,and 21 resources. Works with Claude, GPT, Cursor, and any MCP-compatible client.Zero install via hosted SSE, or run locally via stdio.

The problem

Every smart contract call on TRON requires energy. Without energy, TRX tokens areburned as fees. A single USDT transfer burns 3-13 TRX depending on whether thereceiving address has held USDT before (approximately $1-4 at current prices).With rented energy, the same transfer costs 0.17-1.43 TRX. That is up to a94% reduction in transaction costs.

High-volume wallets -- exchanges, payment processors, trading bots -- burnthousands of TRX daily without resource optimization.

The TRON energy market is fragmented. Each provider has different prices (22-80 SUNper unit), different APIs, different durations (5 minutes to 30 days). Prices changeevery 30 seconds. No single tool aggregates them all, compares prices in real time,and routes orders to the cheapest source.

MERX solves this by aggregating all connected providers behind one API.

Platform overview

Quick start

Three paths depending on your use case.

Path 1: Web platform

Go to merx.exchange. Sign in. Deposit TRX. Trade energyand bandwidth at the best available price. No code required.

Path 2: API / SDK

Install the JavaScript SDK:

npm install @merx/sdk

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

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:

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

# 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: MCP for AI agents

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

{
  "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 52 tools available.
-> Key never leaves your machine.

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

npm install -g merx

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

All 52 tools available from the first message.

Access levels

What sets MERX apart

Multi-provider routing

All connected energy and bandwidth providers are aggregated. Orders are routed tothe cheapest source automatically. If one provider fails or runs out of capacity,the next cheapest fills the order. Prices cover both energy and bandwidth acrossevery available duration tier.

Resource-aware transactions

Every write operation (USDT transfer, token swap, contract call) automaticallyestimates energy AND bandwidth needed, buys the deficit at the best market price,waits for delegation to arrive on-chain, then executes. The caller never burns TRXunnecessarily. Tested on mainnet: a USDT transfer with auto-resources saves up to94% compared to burning.

Exact energy simulation

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

Intent execution

Describe a multi-step plan (transfer + swap + another transfer). MERX simulates allsteps, estimates total resource cost, and executes sequentially. Stateful simulation:energy consumed by step 1 is not available for step 2. Accurate total cost estimatesfor complex workflows.

Standing orders

Server-side 24/7 automation stored in PostgreSQL. Example: "Buy 65,000 energy whenprice drops below 20 SUN." Trigger types: price_below, price_above, schedule(cron), balance_below. Persists across restarts. Works when the client is offline.

Delegation monitors

Watch energy and bandwidth delegations on any address. Alert before expiry.Auto-renew with configurable max price. Monitor types: delegation_expiry,balance_threshold, price_alert.

x402 pay-per-use

No account needed. No pre-deposit. Create an invoice, pay with TRX from any wallet,and receive energy delegation. Complete flow in one API call. Tested on mainnet:1.43 TRX payment resulted in 65,050 energy delegated.

Full MCP protocol

The only TRON MCP server using all three MCP primitives: tools (52), prompts (30),and resources (21 -- 14 static + 7 templates). Two transport modes: hosted SSE(zero install) and local stdio (full key management).

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

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. Usersnever need TronGrid API keys. MERX manages all RPC infrastructure, caching, andfailover server-side. The only operation that stays on the client: transactionsigning 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%

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

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)

Authenticated endpoints (API key required)

x402 endpoints (zero registration)

Full API reference: merx.exchange/docs/api-reference

MCP server

MERX provides a full MCP (Model Context Protocol) server for AI agents. 52 toolsacross 15 categories, 30 pre-built prompts, and 21 live data resources.

Tool categories

Prompts (30)

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

Resources (21)

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

URI Templates:

Example conversations

Check prices and buy energy:

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:

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:

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 52 tools with auth requirements. For input schemas and output examples, seedocs/TOOLS.md.

Price Intelligence

Resource Estimation

Resource Trading

Account Management

Agent Convenience

On-chain Queries

Token Operations

Smart Contracts

Network Utilities

DEX Swaps

Onboarding

Payments

Intent Execution

Standing Orders and Monitors

Session Management

SDKs

JavaScript / TypeScript

npm install @merx/sdk

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()

Python

pip install merx-sdk

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()

REST API

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

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

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, ... }
}

Webhooks

Register webhook endpoints to receive HTTP POST notifications for account events.

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"]}'

Security: Every webhook request includes an X-Merx-Signature header containingan HMAC-SHA256 signature computed with your webhook secret. Verify this signaturebefore 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.

# 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 orAPI. The tool builds a TRX transfer with the correct memo, signs it locally, andbroadcasts. Balance is credited in 1-2 minutes.

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 toolcall via create_paid_order.

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...

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. Workswhen the client is offline.

Trigger types:

Action types:

Example:

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-renewwith configurable max price.

Example:

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 differencebetween burning TRX (no energy) and renting energy through MERX.

Cost comparison

Numbers assume the cheapest available provider at time of order. Actual burn costvaries 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 needsapproximately 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 thesender depending on the recipient's account state.

Error handling

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

{
  "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

Security

Private key handling

• Private keys are set via environment variable (TRON_PRIVATE_KEY) or theset_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 useronly 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_keytool in-session.
• Create an account and get an API key without leaving the conversation using thecreate_account tool.

What MERX can and cannot do

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

Key findings from mainnet testing

Comparison with alternatives

Factual comparison based on publicly available information.

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

Documentation

License

MIT. See LICENSE.