Tron RPC node & Wallet API — chain ID 728126428
Last updated:
Get API key Read the documentation
Network details
| Network | Tron mainnet |
|---|---|
| Chain ID (EVM surface) | 728126428 |
| Currency | TRX |
| EVM JSON-RPC | https://triport.io/rpc/tron |
| Native wallet HTTP | https://triport.io/rpc/tron/wallet (POST) |
| Authentication | x-token: $TRIPORT_API_KEY (Authorization: Bearer also accepted), scope tron:rpc |
| Transaction submission | Not part of the product |
Try it without a key
https://triport.io/public/tron — 15 req/s reads; reads only, no transaction sends — one budget shared by every caller. JSON-RPC over HTTPS POST with no key and no account; it is not a plan, and there is no WebSocket.
Only EVM JSON-RPC reads: historical state is unavailable (block must be latest). eth_estimateGas, eth_sendRawTransaction, eth_getBlockReceipts and eth_feeHistory return -32601. Native wallet HTTP calls require a key.
curl https://triport.io/public/tron \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# -> {"jsonrpc":"2.0","id":1,"result":"0x2b6653dc"}Checked by a live probe on 2026-11-01. Bodies up to 256 KiB; a batch of 20 calls is answered.
TRX accounts are not managed through EVM network configs, so there is no wallet button here.
What works today
| Capability | Status | Notes |
|---|---|---|
| EVM JSON-RPC reads | Available | EVM hex addresses differ from native; state profile is latest-oriented; historical blocks do not prove old state. |
| eth_getLogs | Available | up to 100 blocks per request |
| Native wallet HTTP (read) | Available | Base58 needs visible=true, hex addresses use the 41 prefix; an empty object after a wrong address is not proof of a missing account; no submission. |
Two surfaces, and which one to use
The EVM surface is the one your existing tooling already speaks: balances, code and storage, blocks, calls and logs, addressed as 0x hex. The native wallet surface is where Tron's own concepts live — account state and staked resources (getaccount), energy prices, chain parameters, witnesses, contract info, and triggerconstantcontract for a call that is executed but never sent. Most integrations need both: EVM for portable reads, wallet HTTP for anything Tron-specific.
getaccountresource (remaining energy and bandwidth) is not served today. For native request formats, see the Tron wallet API reference.
Address formats are the most common failure
The wallet surface accepts base58 addresses only with visible=true, and its hex form carries the 41 prefix, while the EVM surface expects 0x hex. A request with the wrong format usually returns an empty object rather than an error — which is not proof that the account does not exist. Check the format before concluding anything about the account, and see the wallet reference.
What teams run on it
These are supported workload patterns, with configured budgets rather than measured throughput promises.
- Monitor USDT deposits with
eth_getLogsfiltered to the USDT contract and its Transfer event, in windows of at most 100 blocks. Use the heavy budget, deduplicate logs, and inspect receipts. See scan USDT transfer history. - Read TRC-20 balances with
eth_callandbalanceOf(address), on the ordinary read budget. Encode the holder as a 20-byte ABI address, without TRON's41prefix. - Estimate before signing:
triggerconstantcontractsuppliesenergy_used;getchainparameterssupplies the burn prices. Read about energy and bandwidth and estimate a USDT transfer fee.
Planning example: at TRON's nominal 3-second block interval, a day is 86,400 / 3 = 28,800 blocks. At 100 blocks per request that is 288 windows. Basic's configured 5 heavy requests/second gives 288 / 5 = 57.6 seconds (about 58 seconds) of request-budget time. This excludes network time, retries, receipt reads and competing calls; it is not a backfill benchmark. Block interval: TRON consensus documentation, checked 2026-10-25; budgets: TRON limits.
What you can and cannot do on TRON here
| Task | Method | Surface | Budget | On Triport |
|---|---|---|---|---|
| TRX balance and account state | eth_getBalance / getaccount | JSON-RPC / wallet HTTP | tron_read_rpc | Latest state |
| TRC-20 balance | eth_call | JSON-RPC | tron_read_rpc | Read-only |
| USDT event history | eth_getLogs | JSON-RPC | tron_read_rpc_heavy | At most 100 blocks per request |
| Included transaction execution | gettransactioninfobyid | Wallet HTTP | tron_read_rpc | May return an empty object before inclusion; not solidified finality |
| Energy simulation | triggerconstantcontract | Wallet HTTP | tron_read_rpc_heavy | Read energy_used; estimateenergy is not served |
| Resource burn prices | getchainparameters / getenergyprices / eth_gasPrice | Wallet HTTP / JSON-RPC | tron_read_rpc | Energy price was 100 sun on 2026-10-25; query again before budgeting |
| Remaining energy and bandwidth | getaccountresource | Wallet HTTP | — | Not served |
| Transaction submission | broadcasttransaction / eth_sendRawTransaction | Wallet HTTP / JSON-RPC | — | Not served on any plan |
| Solidified data | /walletsolidity | Native HTTP | — | Not served |
| Witness inventory | listwitnesses | Wallet HTTP | tron_read_rpc | Read-only |
The wallet methods above need a key. The public URL exposes only JSON-RPC reads; a key or a higher plan does not enable the routes marked not served.
Historical blocks do not prove historical state
Tron's state profile here is latest-oriented. Fetching an old block succeeds, but a state read at that height may not — so a working eth_getBlockByNumber on an old block is not evidence that eth_getBalance or eth_getStorageAt will answer for the same height. Treat deep state reads as unsupported unless you have verified the exact range you need.
Testnet
TRON testnets: Nile (chain ID 3448148188) and Shasta (chain ID 2494104990). Triport serves mainnet only; switch the URL and chain ID for test work — TRON testnet connection values.
These IDs are JSON-RPC eth_chainId values, recorded on 2026-10-24.
Terms on this page: TRC-20 · Super representative · Solidified block.
Limits and plans
2× burst buffer, included. Finite request-rate limits show sustained RPS and short burst capacity. A full buffer at 20 RPS can absorb up to 40 requests at once and refills at 20 requests per second. There is no quota on the number of bursts and no extra charge for them. Size ongoing traffic to sustained RPS. Categories with no per-category cap have no numeric burst ceiling. How burst capacity works.
| Capability | Free trial (7 days) | Basic | Pro | Business | Enterprise |
|---|---|---|---|---|---|
| EVM + wallet reads (tron_read_rpc) | 15 RPS sustained · up to 30 burst | 20 RPS sustained · up to 40 burst | 100 RPS sustained · up to 200 burst | 250 RPS sustained · up to 500 burst | no per-category cap |
| Heavy: eth_getLogs, heavy wallet calls | 2 | 5 | 20 | 80 | no per-category cap |
| Transaction submission | — | — | — | — | — |
The heavy budget is much smaller than the ordinary read budget on Tron — eth_getLogs and heavy wallet calls draw on it, so log backfills should be paced against 2/5/20/80 rather than the headline read rate. Plans: Basic $20, Pro $249, Business $499, Enterprise from $999 per month; Free is a 7-day trial with a single key in the EU region. See Tron limits.
Every plan with its limits on every network, and what a plan costs at its cap: RPC pricing.
Quickstart
# EVM read
curl https://triport.io/rpc/tron \
-H "x-token: $TRIPORT_API_KEY" -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
# Native wallet read (base58 needs visible=true)
curl https://triport.io/rpc/tron/wallet/getaccount \
-H "x-token: $TRIPORT_API_KEY" -H 'Content-Type: application/json' \
-d '{"address":"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t","visible":true}'FAQ
- What is the Tron RPC URL?
- https://triport.io/rpc/tron for EVM-style JSON-RPC and https://triport.io/rpc/tron/wallet for the native wallet HTTP reads. Authenticate with the x-token header, or use the keyed URL https://triport.io/r/<API_KEY>/tron where a custom header is impossible.
- What is Tron's chain ID for EVM tools?
- 728126428. Tron exposes an EVM-compatible JSON-RPC surface, so viem, ethers and Hardhat can read from it, but the native concepts — energy, bandwidth, witnesses — live on the wallet HTTP surface instead.
- Can I broadcast Tron transactions through Triport?
- No. Both surfaces are published read-only: there is no submission route on any plan. triggerconstantcontract runs a contract call without sending it, which is a read, not a broadcast.
- Why does my address return an empty object?
- Almost always an address-format mismatch. The wallet HTTP surface needs visible=true for base58 addresses, and hex addresses carry the 41 prefix, while the EVM surface uses 0x hex. An empty object after a wrong address is not proof that the account does not exist.
- What is the eth_getLogs limit on Tron?
- Up to 100 blocks per request, and it draws on the heavy read budget: 2/5/20/80 RPS on Free trial/Basic/Pro/Business. Plan log backfills around that rate, not around the ordinary read rate.
- Can I read historical Tron state?
- Reading a historical block is not the same as reading state at that block: the state profile is latest-oriented, so an old block being returned does not prove that state at that height is available.
- What are the Tron rate limits?
- Ordinary reads 15/20/100/250 RPS on Free trial/Basic/Pro/Business; heavy reads, including eth_getLogs, 2/5/20/80. Enterprise has no per-category cap.
- Is there a free TRON RPC?
- https://triport.io/public/tron is a keyless public endpoint with 15 read requests per second shared by all callers. It serves EVM-style JSON-RPC reads only, with no historical state or wallet HTTP API. For native wallet reads, use a key from the 7-day trial.
- Does Triport serve Nile or Shasta?
- No. Triport serves TRON mainnet only. Nile and Shasta are separate test networks; their connection values and official documentation are on the TRON chain-config page under Testnet.
- Can I send TRX through the JSON-RPC endpoint?
- No. eth_sendRawTransaction returns JSON-RPC error -32601. A key does not enable sending: broadcasttransaction and /walletsolidity are not served either. Sign and broadcast through a separate wallet or node; Triport supplies read access.
- How do I estimate a USDT transfer fee with this API?
- Simulate transfer(address,uint256) with triggerconstantcontract and check execution succeeded before reading energy_used. Multiply by getEnergyFee from getchainparameters (100 sun per energy in the recorded 2026-10-25 snapshot), then account for bandwidth and resources available elsewhere. The linked fee guide explains the calculation; getaccountresource and estimateenergy are not served.