Tron RPC node & Wallet API — chain ID 728126428

Last updated:

Get API key Read the documentation

Network details

Tron connection values
NetworkTron mainnet
Chain ID (EVM surface)728126428
CurrencyTRX
EVM JSON-RPChttps://triport.io/rpc/tron
Native wallet HTTPhttps://triport.io/rpc/tron/wallet (POST)
Authenticationx-token: $TRIPORT_API_KEY (Authorization: Bearer also accepted), scope tron:rpc
Transaction submissionNot 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

Capabilities and their published status — from the generated capability registry
CapabilityStatusNotes
EVM JSON-RPC readsAvailableEVM hex addresses differ from native; state profile is latest-oriented; historical blocks do not prove old state.
eth_getLogsAvailableup to 100 blocks per request
Native wallet HTTP (read)AvailableBase58 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_getLogs filtered 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_call and balanceOf(address), on the ordinary read budget. Encode the holder as a 20-byte ABI address, without TRON's 41 prefix.
  • Estimate before signing: triggerconstantcontract supplies energy_used;getchainparameters supplies 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, API surface and configured rate-limit category
TaskMethodSurfaceBudgetOn Triport
TRX balance and account stateeth_getBalance / getaccountJSON-RPC / wallet HTTPtron_read_rpcLatest state
TRC-20 balanceeth_callJSON-RPCtron_read_rpcRead-only
USDT event historyeth_getLogsJSON-RPCtron_read_rpc_heavyAt most 100 blocks per request
Included transaction executiongettransactioninfobyidWallet HTTPtron_read_rpcMay return an empty object before inclusion; not solidified finality
Energy simulationtriggerconstantcontractWallet HTTPtron_read_rpc_heavyRead energy_used; estimateenergy is not served
Resource burn pricesgetchainparameters / getenergyprices / eth_gasPriceWallet HTTP / JSON-RPCtron_read_rpcEnergy price was 100 sun on 2026-10-25; query again before budgeting
Remaining energy and bandwidthgetaccountresourceWallet HTTP—Not served
Transaction submissionbroadcasttransaction / eth_sendRawTransactionWallet HTTP / JSON-RPC—Not served on any plan
Solidified data/walletsolidityNative HTTP—Not served
Witness inventorylistwitnessesWallet HTTPtron_read_rpcRead-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.

Configured requests per second by plan — unmeasured capacity
CapabilityFree trial (7 days)BasicProBusinessEnterprise
EVM + wallet reads (tron_read_rpc)15 RPS sustained · up to 30 burst20 RPS sustained · up to 40 burst100 RPS sustained · up to 200 burst250 RPS sustained · up to 500 burstno per-category cap
Heavy: eth_getLogs, heavy wallet calls252080no 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.

Tron EVM read methods