---
updatedAt: 2026-10-19T07:33:08.000Z
agentTools:
  projectIndex: https://developers.tron.network/llms.txt
---

# TRC-10

TRC-10 is a native token standard supported by the TRON protocol. For new token projects, use TRC-20 — it offers better DeFi integration and cross-chain compatibility.

> 📘 **Prerequisites**
>
> * [Token standards overview](https://developers.tron.network/docs/token-standards-overview)

TRC-10 is a native token standard supported by the TRON network. Unlike TRC-20 tokens, it does not rely on the TRON Virtual Machine (TVM) but is implemented directly at the blockchain protocol level. Each account can issue only one TRC-10 token; the current Mainnet issuance fee is 1,024 TRX.

## Issue a TRC-10 token

The issuance fee is burned and is not refundable. The `getAssetIssueFee` chain parameter controls the amount, so it can differ by network or change through governance. Before issuing, query [`wallet/getchainparameters`](https://developers.tron.network/reference/wallet-getchainparameters) for the selected network's current value. For new token projects, [TRC-20](https://developers.tron.network/docs/trc20) is recommended instead. A TRC-10 issuance uses an `AssetIssueContract` transaction. The example below shows both the HTTP API and TronWeb SDK approaches.

### Using the HTTP API

The Fullnode HTTP endpoint `wallet/createassetissue` creates an unsigned TRC-10 issuance transaction. The example uses `visible: true`, so addresses and string fields can use Base58Check and plain-text formats. The start time must be later than the current head-block time; this example opens the issuance window one hour from now for 24 hours.

```bash
BASE_URL=https://api.shasta.trongrid.io   # example — replace with any TRON node (TronGrid, third-party, or self-hosted)
OWNER_ADDRESS="YOUR_SHASTA_ADDRESS"
START_TIME=$(($(date +%s) * 1000 + 3600000))
END_TIME=$((START_TIME + 86400000))

curl -X POST ${BASE_URL}/wallet/createassetissue \
  -H 'Content-Type: application/json' \
  --data-binary @- <<JSON
{
  "owner_address": "${OWNER_ADDRESS}",
  "name": "ExampleToken",
  "abbr": "EXT",
  "total_supply": 100000000,
  "trx_num": 1,
  "num": 1,
  "precision": 6,
  "start_time": ${START_TIME},
  "end_time": ${END_TIME},
  "description": "Example TRC-10 token",
  "url": "https://example.com",
  "free_asset_net_limit": 0,
  "public_free_asset_net_limit": 0,
  "visible": true
}
JSON
```

After receiving the unsigned transaction, sign it with the owner's private key and broadcast it. See [Transactions](https://developers.tron.network/docs/tron-protocol-transaction) for the sign-and-broadcast flow.

### Using the TronWeb SDK

```javascript
const { TronWeb } = require('tronweb');

const privateKey = process.env.PRIVATE_KEY;
if (!/^[0-9a-fA-F]{64}$/.test(privateKey || '')) {
    throw new Error('Set PRIVATE_KEY to a 64-character Shasta test private key');
}

const tronWeb = new TronWeb({
    fullHost: 'https://api.shasta.trongrid.io',
    privateKey
});

async function main() {
    const createAssetAddress = tronWeb.defaultAddress.base58;
    const saleStart = Date.now() + 60 * 60 * 1000;
    const saleEnd = saleStart + 24 * 60 * 60 * 1000;

    const trcOptions = {
        name: 'ExampleToken',
        abbreviation: 'EXT',
        description: 'Example TRC-10 token',
        url: 'https://example.com',
        totalSupply: 100000000,
        trxRatio: 1,
        tokenRatio: 1,
        saleStart,
        saleEnd,
        freeBandwidth: 0,
        freeBandwidthLimit: 0,
        frozenAmount: 0,
        frozenDuration: 0,
        precision: 6
    };

    const unsignedTransaction = await tronWeb.transactionBuilder.createAsset(
        trcOptions,
        createAssetAddress
    );
    const signedTransaction = await tronWeb.trx.sign(unsignedTransaction, privateKey);
    const broadcastResult = await tronWeb.trx.sendRawTransaction(signedTransaction);
    if (broadcastResult.result !== true) {
        throw new Error(
            `The node did not accept the broadcast. Before rebuilding, query the original txID ${signedTransaction.txID}: ${JSON.stringify(broadcastResult)}`
        );
    }
    console.log('Broadcast accepted. TX ID:', signedTransaction.txID);
}

main().catch(error => {
    console.error(error);
    process.exitCode = 1;
});
```

`result: true` means only that the node accepted the broadcast request. Continue querying `/walletsolidity/gettransactionbyid` with this `txID`. A matching transaction with `ret[0].contractRet` equal to `SUCCESS` confirms that the issuance executed successfully and entered the solidified canonical chain. If the query still returns an empty object, keep tracking the original `txID` instead of rebuilding the transaction immediately.

## Transfer a TRC-10 token

Use the `TransferAssetContract` transaction type — this is different from TRX transfers (which use `TransferContract`) and from TRC-20 transfers (which call the smart contract's `transfer` function).

### Using the HTTP API

The Fullnode HTTP endpoint `wallet/transferasset` creates an unsigned TRC-10 transfer:

```bash
BASE_URL=https://api.shasta.trongrid.io   # example — replace with any TRON node (TronGrid, third-party, or self-hosted)
curl -X POST ${BASE_URL}/wallet/transferasset -d '{
  "owner_address": "41d1e7a6bc354106cb410e65ff8b181c600ff14292",
  "to_address": "41e552f6487585c2b58bc2c9bb4492bc1f17132cd0",
  "asset_name": "31303030303838",
  "amount": 100
}'
```

`asset_name` contains the UTF-8 hexadecimal representation of token ID `1000088` because this request uses hexadecimal addresses and omits `visible`. If `visible` is `true`, use the string `"1000088"` instead. The sender must hold the selected TRC-10 token. After creating the unsigned transaction, sign and broadcast it. See [Transactions](https://developers.tron.network/docs/tron-protocol-transaction) for details.

### Using the TronWeb SDK

```javascript
const { TronWeb } = require('tronweb');

const privateKey = process.env.TRON_PRIVATE_KEY;
if (!/^[0-9a-fA-F]{64}$/.test(privateKey || '')) {
    throw new Error('Set TRON_PRIVATE_KEY to a 64-character hexadecimal Shasta test private key');
}
const tronWeb = new TronWeb({
    fullHost: 'https://api.shasta.trongrid.io',
    privateKey
});
const fromAddress = tronWeb.defaultAddress.base58;
const toAddress = "TM2TmqauSEiRf16CyFgzHV2BVxBejY9iyR";
const tokenID = "1000088";
const amount = 1000;

// Create an unsigned TRC-10 transfer transaction
const tradeobj = await tronWeb.transactionBuilder.sendToken(
    toAddress,
    amount,
    tokenID,
    fromAddress
);

// Sign
const signedtxn = await tronWeb.trx.sign(tradeobj, privateKey);

// Broadcast and check whether the node accepted the request
const broadcastResult = await tronWeb.trx.sendRawTransaction(signedtxn);
if (broadcastResult.result !== true) {
    throw new Error(
        `The node did not accept the broadcast. Before rebuilding, query the original txID ${signedtxn.txID}: ${JSON.stringify(broadcastResult)}`
    );
}
console.log('Broadcast accepted. TX ID:', signedtxn.txID);
```

After broadcasting, query `/walletsolidity/gettransactionbyid` with this txID. A matching transaction with `ret[0].contractRet` equal to `SUCCESS` confirms that the transfer executed successfully and entered the solidified canonical chain. Do not treat the broadcast response as a transaction receipt.

## Check TRC-10 balance

### Using the HTTP API

The Fullnode HTTP endpoint `wallet/getaccount` returns account information; TRC-10 balances appear in the `assetV2` array of the response:

```bash
BASE_URL=https://api.shasta.trongrid.io   # example — replace with any TRON node (TronGrid, third-party, or self-hosted)
curl -X POST ${BASE_URL}/wallet/getaccount -d '{
  "address": "TM2TmqauSEiRf16CyFgzHV2BVxBejY9iyR",
  "visible": true
}'
```

### Using the TronWeb SDK

```javascript
const address = "TM2TmqauSEiRf16CyFgzHV2BVxBejY9iyR";

// TRC-10 balances are in the assetV2 array of the returned account
const account = await tronWeb.trx.getAccount(address);
console.log('TRC-10 balances:', account.assetV2);
```

***

## Reference

For the complete list of TRC-10 API endpoints (query by account / ID / name, update token info, participate in issuance, and more), see the [TRON HTTP API reference](https://developers.tron.network/reference).

## Related resources

* [TRC-20](https://developers.tron.network/docs/trc20) — recommended fungible token standard for new projects (TVM-based, ERC-20 compatible)
* [Transferring TRC-10 in smart contracts](https://developers.tron.network/docs/trc10-transfer-in-smart-contracts) — interact with TRC-10 tokens from Solidity
* [Token standards overview](https://developers.tron.network/docs/token-standards-overview)
* [Transactions](https://developers.tron.network/docs/tron-protocol-transaction) — sign and broadcast flow used by TRC-10 operations