---
name: tron-resources-x402
description: Find TRON products with one search, then pay per call in USDC via x402 — get TRON energy, send TRON transactions (USDT/TRC-20, TRX, contract calls) without holding TRX, read a TRON full node and watch TRON addresses, paying in USDC on Base via x402 v2 — no account, no API key. Use when an agent must move USDT or call a contract on TRON and the sender lacks energy/TRX, needs a price or energy estimate for a TRON transaction, a TRON RPC endpoint, or notifications about TRON addresses.
---

# TRON energy and transaction sending for USDC (x402)

## How to use it — always these steps

1. **Find:** `GET https://api.awesomefee.com/v1/search?q=<what you need>` (free; English or Russian, e.g. `q=send transaction`,
   `q=buy energy`, `q=rpc`, `q=events webhook`; no `q` = the whole catalogue; `limit` 1–50). Each result has `id`,
   `title`, `description`, `method`, `url`, `parameters` (JSON Schema of the body), `price`, `payment`
   (`free` | `x402` | `pass`), a curl `example` and what it `returns`.
2. **Call** the returned URL with an x402 v2 HTTP client (`@x402/fetch`, `@x402/axios`, Python `x402`).
3. **Pay on 402:** the client signs the USDC terms from YOUR wallet (Base, EIP-3009, no gas) and repeats the request.
4. **Get the result** (`200`, or `202` + `status_url` while it runs).

No account, no API key, nothing to install. The reference below describes each product.

API: `https://api.awesomefee.com` · Catalog: `GET https://api.awesomefee.com/x402/v1` · OpenAPI: `https://api.awesomefee.com/openapi.json` · MCP: `https://api.awesomefee.com/mcp` ·
Docs: `https://awesomefee.com/docs/en/agents/overview/`

## When to use

- You must send USDT (TRC-20) or call a contract on TRON and the sender has no energy: without it the network
  **burns TRX** from the sender (100 SUN per energy unit; a USDT transfer ≈ 64 285 energy ≈ 6.4 TRX; to an address that
  never held USDT ≈ 130 285 energy). If the sender has no TRX at all, the transaction fails.
- You hold USDC on Base (any EVM wallet) but no TRX — pay in USDC, gasless (EIP-3009 signature).
- You need a price or an estimate before acting — free.
- You need TRON node reads or address notifications — prepaid passes, cheaper than typical RPC providers.

## TRON resources in 5 lines

- **Energy** pays for smart-contract execution (USDT transfers, contract calls). **Bandwidth** pays for bytes of every
  transaction (~345 bytes for a USDT transfer, ~270 for TRX).
- Every address gets 600 free bandwidth bytes per day; energy is never free.
- Missing resource → the network burns TRX from the sender: 100 SUN/energy, 1 000 SUN/byte (1 TRX = 10^6 SUN).
- Energy can be delegated to an address from someone else's stake: that is what we do; the sender keeps its keys.
- A new receiver of USDT costs ~2× energy (new storage slot).

## Endpoints (base `https://api.awesomefee.com`)

| Need | Call | Price |
|---|---|---|
| Find the right product and URL | `GET /v1/search?q=…` | free |
| Price of energy / sending; pass tiers | `GET /x402/v1/quote?product=energy&amount=65000` (`product`: energy, send, proxy_pass, rpc_pass, events_sub) | free |
| Energy and bandwidth of a transaction, what is missing, price | `POST /x402/v1/tron/estimate {"transaction": {…}}` or `{"trc20_transfer": {"owner","token","to","amount"}}` | free |
| What an address spends and burns (7 days) | `GET /x402/v1/address/T…` | free |
| Send a **signed** transaction with its energy included | `POST /x402/v1/tron/send {"signed_tx": {…}}` | x402 |
| Energy to any address for 1000 blocks (~50 min) | `POST /x402/v1/tron/energy {"address":"T…","amount":65000}` | x402 |
| Pass: send through our Proxy, energy per transaction from the pass | `POST /x402/v1/proxy/pass {"tier":"proxy-5","senders":["T…"]}` (≤ 5 senders) | x402 |
| Pass: read our full TRON node (`/rpc/wallet/*`, `/rpc/walletsolidity/*`, `/rpc/jsonrpc`) | `POST /x402/v1/rpc/pass {"tier":"rpc-s"}` | x402 |
| Pass: events of addresses (webhook or WebSocket) | `POST /x402/v1/events/sub {"tier":"ev-s"}` (optional `addresses`, https `webhook_url`) | x402 |
| Pass balance | `GET /x402/v1/pass` + `Authorization: Bearer <token>` | free |
| State of a paid order, refund | `GET /x402/v1/payments/{payment_id}` | free |

`tier` is the tier name or its USDC price (`{"tier":9}` = `rpc-s`). A pass answer: `pass_id`, `token` (`tlp_…`, keep it),
`tier`, `unit`, `added_credits`, `expires_at`, `limits`, `rpc_url` or `events_url`, `balance_url`. Buying again with
`Authorization: Bearer <token>` tops that pass up (credits add, the later expiry wins). `GET /x402/v1/pass` answers
`credits_left`, `spent`, `held`, `paid_usdc`. The catalogue of everything sold: `GET /x402/v1`.

## Pass tiers (`tier` = name or USDC price)

Proxy (`proxy/pass`; credits = USDC, each sent transaction is charged the agent price of the energy supplied; ≤ 5 senders):
proxy-5 (5), proxy-20 (20), proxy-100 (100), 30 days.

Node reads (`rpc/pass`; 1 credit per ordinary call, 2–10 for heavy ones like blocks and logs):

| Tier | USDC | Credits | Rate | Days |
|---|---|---|---|---|
| rpc-trial | 0.5 | 50 000 | 5 rps | 7 |
| rpc-s | 9 | 1 000 000 | 10 rps | 30 |
| rpc-m | 35 | 5 000 000 | 25 rps | 30 |
| rpc-l | 120 | 20 000 000 | 50 rps | 30 |
| rpc-xl | 300 | 60 000 000 | 100 rps | 30 |

Address events (`events/sub`; 1 credit per delivered event):

| Tier | USDC | Addresses | Subscriptions | Events | Days |
|---|---|---|---|---|---|
| ev-s | 3 | 10 | 3 | 200 000 | 30 |
| ev-m | 15 | 100 | 10 | 2 000 000 | 30 |
| ev-l | 60 | 1 000 | 25 | 10 000 000 | 30 |

## Paying (x402 v2)

1. Call the paid endpoint as is → `402`, header `PAYMENT-REQUIRED` = base64 JSON `{x402Version:2, accepts:[{scheme:"exact",
   network:"eip155:8453", amount:"<USDC atomic, 6 decimals>", asset:"<USDC>", payTo, maxTimeoutSeconds, extra}]}`.
2. Sign one `accepts` entry with your EVM wallet (EIP-3009 `transferWithAuthorization`, no gas) → PaymentPayload.
3. Repeat the same request with header `PAYMENT-SIGNATURE: <base64 PaymentPayload>` → `200` + result + `PAYMENT-RESPONSE`
   (settlement tx on Base). `202 {"status":"pending","status_url":…}` = paid, still running: poll `status_url`.

Do not hand-roll it: `@x402/fetch` / `@x402/axios` (JS) or `x402` (Python, `x402_requests`) do steps 1–3.

```js
import { wrapFetchWithPaymentFromConfig } from '@x402/fetch';
import { ExactEvmScheme } from '@x402/evm/exact/client';
import { privateKeyToAccount } from 'viem/accounts';
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: 'eip155:8453', client: new ExactEvmScheme(privateKeyToAccount(process.env.EVM_PRIVATE_KEY)) }],
  spendControls: { maxAmountPerPayment: '$1' },
});
const r = await pay('https://api.awesomefee.com/x402/v1/tron/send', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ signed_tx }) });
```

## Recipe: send USDT on TRON without TRX

1. Build the TRC-20 `transfer` with your TRON library (TronWeb: `transactionBuilder.triggerSmartContract` on
   `TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t`, `transfer(address,uint256)`), set **expiration ≥ 2 min** ahead, sign it with
   the sender's TRON key. We never see that key and never change the transaction.
2. `POST /x402/v1/tron/estimate {"transaction": signed}` — check `estimate.missing_energy`, `estimate.would_revert`,
   `estimate.bandwidth_source` (must not be `unavailable`), `cover.price_usdc`.
3. `POST /x402/v1/tron/send {"signed_tx": signed}` with x402 → `{status:"confirmed", txid, block, result:"SUCCESS",
   energy_used, energy_burned_sun:0}`.

## Recipe: TronWeb on our node with an RPC pass

`new TronWeb({ fullHost: 'https://api.awesomefee.com/rpc', headers: { 'TRON-PRO-API-KEY': token } })` — reads only; broadcasting is
refused there (use `tron/send` or a Proxy pass: `https://api.awesomefee.com/proxy/wallet/broadcasttransaction` with
`Authorization: Bearer <proxy token>`).

## Rules and refusals

- Prices: **agent price** in USDC at the live TRX/USD rate. `GET /x402/v1/quote` shows the price with the full payment
  terms (`accepts[0]`, `pay`) by GET; quotes show `burn_equivalent_sun` / `burn_equivalent_usd`.
- An empty or incomplete body gets 402 with example terms (`error` names the missing fields); paying them gives a new
  402, nothing is charged.
- Refused before payment (no 402, nothing charged): expired transaction, a call that would revert, a type other than
  TRX / TRC-20 and contract calls / TRC-10, sender not activated, more than 300 000 energy, the sender lacks its own or
  free bandwidth (`BANDWIDTH_UNAVAILABLE`: bandwidth is not sold yet), no capacity (`NO_CAPACITY`), rate limit
  (`RATE_LIMITED`, `Retry-After`).
- Paid but not delivered by our fault → automatic USDC refund to the payer (see `payments/{id}`). Delivered but your
  transaction reverted on chain → no refund (the resource was used).
- Energy bought with `tron/energy` lasts 1000 blocks; unused energy is not refunded.
- Repeating the **same** payment returns the same answer; a new payment is a new order.

## MCP

A thin directory: one tool `search` (the same `/v1/search`) and these docs as resources (llms.txt, SKILL.md, OpenAPI).
Remote: `https://api.awesomefee.com/mcp` (Streamable HTTP, stateless). Local: `npx -y tron-x402-mcp` with
`TRON_X402_API_URL=https://api.awesomefee.com`. The MCP server never pays: call the product URL with your own x402 client.
