What TRON energy is, where it comes from, and what it costs

Every USDT transfer on TRON runs the USDT contract, and every contract call needs energy. If the sending account has no energy, the network burns TRX from its balance instead. On 3 November 2026 that burn was 6.43 TRX ($2.07) for a transfer to a wallet that already holds USDT.

That makes energy the line item that decides what a TRON product costs to run. This guide explains what energy is, how the network creates and shares it, how it recovers, and the three ways an account can pay for it. Every number comes from TRON mainnet, read through the Dwellir TRON endpoint on 3 November 2026, or from the java-tron source code.

TRON energy in one paragraph

Energy is TRON's unit of smart contract computation. The TRON Virtual Machine (TVM) charges energy for each instruction a contract runs, the way the EVM charges gas. The difference is in how you pay. On Ethereum, every transaction pays gas in ETH. On TRON, an account can hold a renewable energy allowance, so a contract call can cost 0 TRX. Only when the allowance runs out does the network burn TRX at a fixed price per unit.

TRON meters a second resource, bandwidth, for the size of every transaction in bytes. A plain TRX transfer needs only bandwidth. A USDT transfer needs both.

The supply and burn prices come from wallet/getchainparameters and wallet/getaccountresource at 14:02 Stockholm time on 3 November 2026: getTotalEnergyLimit 180,000,000,000, getEnergyFee 100, getTransactionFee 1,000 and getFreeNetLimit 600. One sun is 0.000001 TRX. The USDT energy figures are measured receipts from the same day.

Where energy comes from

TRON creates a fixed pool of 180 billion energy per day and splits it among everyone who stakes TRX for energy. Your share is proportional to your stake. The official formula is:

your energy = (your TRX staked for energy / all TRX staked for energy) x 180,000,000,000

The network-wide stake is the TotalEnergyWeight field of wallet/getaccountresource. At 14:02 Stockholm time it was 18,483,643,671 TRX. That gives:

180,000,000,000 / 18,483,643,671 = 9.7383 energy per staked TRX per day

This ratio is not a constant. It falls when other holders stake more and rises when they unstake. Read it from the API before you size a stake. Hard-coded ratios such as "280 energy per TRX" in older tutorials are off by 29 times today.

Staking for energy at 9.7383 energy per TRX means:

Bandwidth works the same way with its own pool. 43,200,000,000 bandwidth over a TotalNetWeight of 26,626,259,930 TRX is 1.6225 bandwidth per staked TRX per day.

How energy recovers

Energy is not spent once and gone. When an account uses energy, the usage decays to zero over a 24-hour window, and the allowance becomes available again. java-tron applies the decay linearly: after 12 hours, half of a past usage has recovered (ResourceProcessor.java).

Two consequences matter for capacity planning:

• Staked energy is a rate, not a balance. 6,601 staked TRX covers one USDT transfer to a holder per 24 hours. It does not cover 30 transfers on one day and none for the rest of the month.
• A burst still fails or burns. If your payout batch runs once a day, your stake must cover the whole batch at once. Spread the same transfers over the day and part of the allowance recovers between them.

wallet/getaccountresource reports the decayed usage. EnergyLimit minus EnergyUsed is the energy available right now.

Three ways to pay for energy

An account that needs energy can stake for it, receive it from another account, or let the network burn TRX.

The USD figure uses CoinGecko's TRX price of $0.321678 at 14:05 Stockholm time.

Staking: the 14-day commitment

Staking under Stake 2.0 locks TRX in your own account. You choose energy or bandwidth per stake. The rules that affect an operator:

• Unstaking takes 14 days. wallet/unfreezebalancev2 starts a waiting period of getUnfreezeDelayDays, which is 14. The resource disappears at once. After the wait, wallet/withdrawexpireunfreeze moves the TRX back to your balance.
• At most 32 unstake operations can be pending. java-tron rejects the 33rd (UnfreezeBalanceV2Actuator.java).
• You can cancel. wallet/cancelallunfreezev2 returns every pending unstake to stake and credits any that already expired to your balance.
• Staked TRX keeps voting power. On mainnet each staked TRX gives 1 TRON Power, which you can vote with through wallet/votewitnessaccount.

Staking makes sense when your contract-call volume is steady and you hold the TRX anyway. A treasury that holds 6.6 million TRX can stake it and cover 1,000 USDT transfers a day without burning anything.

Delegation and rental

Stake 2.0 lets any staker hand part of its energy to another address with wallet/delegateresource. The receiver uses that energy as its own. The staker keeps ownership and takes it back with wallet/undelegateresource.

This is the base of TRON's energy rental market. A renter pays a provider, and the provider delegates energy to the renter's address for a set time. The TRON developer docs name JustLend DAO Energy Rental as one of these services. Delegation is also how a company shares one treasury stake across its hot wallets. For one hour of rental traffic measured on mainnet, see how the TRON energy rental market works.

Delegation has one safety switch: the lock. A delegation with lock: true cannot be reclaimed until its lock_period ends. The period counts in blocks of 3 seconds, so 28,800 blocks is 1 day. With no period given, java-tron sets 3 days. The maximum is getMaxDelegateLockPeriod, 864,000 blocks or 30 days (DelegateResourceActuator.java). An unlocked delegation can disappear before your transaction lands.

Burning TRX

If an account has no energy, or not enough, TRON burns TRX for the rest at getEnergyFee: 100 sun per energy today. The transaction's fee_limit caps the burn. If the cap is too low, the call fails with OUT_OF_ENERGY and the energy it used is still charged. getMaxFeeLimit sets the highest allowed cap: 15,000 TRX.

Burning needs no setup and no locked capital. It is the most expensive method per transfer, and the price is a governance parameter. The Super Representatives cut getEnergyFee from 210 to 100 sun on 29 August 2025, which cut the burn cost of every contract call by 52%.

Why the same transfer costs different energy

Energy per call is not fixed per method. Two factors move it:

• Storage writes. A USDT transfer to an address that has never held USDT creates a new balance slot. That costs 130,285 energy on mainnet today, against 64,285 for a transfer to an existing holder.
• Dynamic energy. TRON raises the energy cost of a contract that used more than getDynamicEnergyThreshold (5,000,000,000 energy) in the last maintenance cycle of 6 hours. The multiplier tops out at 1 + getDynamicEnergyMaxFactor / 10,000, which is 4.4x with the current factor of 34,000. wallet/getcontractinfo returned an energy_factor of 34,000 for USDT on 3 November 2026, so USDT sits at the ceiling.

Estimate before you sign, with wallet/estimateenergy or wallet/triggerconstantcontract, and check the simulation did not revert. The guide to TRON energy for USDT transfers measures both cases on mainnet receipts and shows how to size fee_limit for them.

Read an account's energy

This script reads the energy an account has now, the live energy-per-TRX ratio and the burn price. It uses only wallet/getaccountresource and wallet/getchainparameters, and runs on Node.js 18 or later with no dependencies.

// Usage: TRON_RPC=https://api-tron-mainnet.n.dwellir.com/<your-api-key> node energy.mjs <address>
const rpc = process.env.TRON_RPC;
const address = process.argv[2];

async function call(method, body = {}) {
  const res = await fetch(`${rpc}/wallet/${method}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`${method}: HTTP ${res.status}`);
  return res.json();
}

const resource = await call('getaccountresource', { address, visible: true });
const { chainParameter } = await call('getchainparameters');
const param = (key) => chainParameter.find((p) => p.key === key)?.value ?? 0;

const energyFeeSun = param('getEnergyFee');
const energyPerTrx = resource.TotalEnergyLimit / resource.TotalEnergyWeight;
const limit = resource.EnergyLimit ?? 0;
const used = resource.EnergyUsed ?? 0;
const available = limit - used;
const usdtTransfer = 64_285; // energy for a USDT transfer to a holder, 3 Nov 2026

console.log({
  energyLimit: limit,
  energyUsed: used,
  energyAvailable: available,
  energyPerStakedTrxPerDay: Number(energyPerTrx.toFixed(4)),
  burnPriceSunPerEnergy: energyFeeSun,
  usdtTransfersCoveredNow: Math.floor(available / usdtTransfer),
  burnCostPerUsdtTransferTrx: (usdtTransfer * energyFeeSun) / 1e6,
});

We ran it at 14:17 Stockholm time against TYAzzycMgo1s1f6fdAP48Bhbf2Z55ghtqa, the address that sent the most energy delegations (3,305) on mainnet between 13:02 and 14:02 that day:

{
  energyLimit: 26297437,
  energyUsed: 18661350,
  energyAvailable: 7636087,
  energyPerStakedTrxPerDay: 9.7383,
  burnPriceSunPerEnergy: 100,
  usdtTransfersCoveredNow: 118,
  burnCostPerUsdtTransferTrx: 6.4285
}

The account had 71% of its energy in recovery. The rest covers 118 more USDT transfers to holders until usage decays.

EnergyLimit includes energy delegated to the account and excludes energy the account delegated away. An account with no stake and no delegation returns no EnergyLimit field, so the script treats it as 0.

Stake, rent or burn: a decision guide

Whichever method you choose, keep a TRX balance and a fee_limit that covers a full burn. A delegation that ends early, or a recipient without USDT, falls back to burning. Without that buffer the transfer fails.

Watch these parameters

Energy prices and supply are governance parameters, not market constants. Read them once per maintenance cycle (6 hours) and alert on change:

• getEnergyFee from wallet/getchainparameters: the burn price.
• TotalEnergyWeight from wallet/getaccountresource: your energy per staked TRX.
• energy_factor from wallet/getcontractinfo for each contract you call: the dynamic energy multiplier.
• getMaxFeeLimit: the ceiling for fee_limit.

Dwellir serves the TRON HTTP API, including the wallet/ and walletsolidity/ paths used here, plus a JSON-RPC interface. The TRON documentation covers each method in this guide, and the TRON network page lists the endpoints. To run TRON payment traffic on dedicated capacity, contact the Dwellir team.