Create a token

Check out the "Getting Started with the Hedera Token Service" video tutorial in JavaScript here.

Create a new fungible or non-fungible token (NFT) on the Hedera network. After you submit the transaction to the Hedera network, you can obtain the new token ID by requesting the receipt.

You can also create, access, or transfer HTS tokens using smart contracts - see Hedera Service Solidity Libraries and Supported ERC Token Standards.

Token Keys

• If any of the token key types (KYC key, Wipe key, Metadata key, etc) are not set during the creation of the token, you will not be able to update the token and add them in the future

• If any of the token key types (KYC key, Wipe key, Metadata key, etc) are set during the creation of the token, you will not be able to remove them in the future

NFTs

For non-fungible tokens, the token ID represents an NFT class. Once the token is created, you must mint each NFT using the token mint operation.

Note: The initial supply for an NFT is required to be set to 0.

Token Properties

Token Properties

Transaction Signing Requirements

• Treasury key is required to sign

• Admin key, if specified

• Transaction fee payer key

Transaction Fees

• For fungible tokens, a CryptoTransfer fee is added to transfer the newly created token to the treasury account

• Please see the transaction and query fees table for the base transaction fee

• Please use the Hedera fee estimator to estimate your transaction fee cost

Methods

Method	Type	Requirement
setTokenName(<name>)	String	Required
setTokenType(<tokenType>)	TokenType	Optional
setTokenSymbol(<symbol>)	String	Required
setDecimals(<decimal>)	int	Optional
setInitialSupply(<initialSupply>)	int	Optional
setTreasuryAccountId(<treasury>)	AccountId	Required
setAdminKey(<key>)	Key	Optional
setKycKey(<key>)	Key	Optional
setFreezeKey(<key>)	Key	Optional
setWipeKey(<key>)	Key	Optional
setSupplyKey(<key>)	Key	Optional
setPauseKey(<key>)	Key	Optional
setFreezeDefault(<freeze>)	boolean	Optional
setExpirationTime(<expirationTime>)	Instant	Optional
setFeeScheduleKey(<key>)	Key	Optional
setCustomFees(<customFees>)	List<CustomFee>	Optional
setSupplyType(<supplyType>)	TokenSupplyType	Optional
setMaxSupply(<maxSupply>)	long	Optional
setTokenMemo(<memo>)	String	Optional
setAutoRenewAccountId(<account>)	AccountId	Optional
setAutoRenewPeriod(<period>)	Duration	Optional
setMetadataKey(<key>)	Key	Optional
setMetadata(<bytes>)	bytes	Optional

Note: Where the Admin, Pause, Freeze, and Wipe keys are left blank, the Supply key will be required as a minimum.

Java

//Create the transaction
TokenCreateTransaction transaction = new TokenCreateTransaction()
        .setTokenName("Your Token Name")
        .setTokenSymbol("F")
        .setTreasuryAccountId(treasuryAccountId)
        .setInitialSupply(5000)
        .setAdminKey(adminKey.getPublicKey())
        .setMetadataKey(metadataKey)
        .setMetadata(metadata)
        .setMaxTransactionFee(new Hbar(30)); //Change the default max transaction fee

//Build the unsigned transaction, sign with admin private key of the token, sign with the token treasury private key, submit the transaction to a Hedera network
TransactionResponse txResponse = transaction.freezeWith(client).sign(adminKey).sign(treasuryKey).execute(client);

//Request the receipt of the transaction
TransactionReceipt receipt = txResponse.getReceipt(client);

//Get the token ID from the receipt
TokenId tokenId = receipt.tokenId;

System.out.println("The new token ID is " + tokenId);

//v2.0.1

JavaScript

//Create the transaction and freeze for manual signing
const transaction = await new TokenCreateTransaction()
     .setTokenName("Your Token Name")
     .setTokenSymbol("F")
     .setTreasuryAccountId(treasuryAccountId)
     .setInitialSupply(5000)
     .setAdminKey(adminPublicKey)
     .setMetadataKey(metadataKey)
     .setMetadata(metadata)
     .setMaxTransactionFee(new Hbar(30)) //Change the default max transaction fee
     .freezeWith(client);

//Sign the transaction with the token adminKey and the token treasury account private key
const signTx =  await (await transaction.sign(adminKey)).sign(treasuryKey);

//Sign the transaction with the client operator private key and submit to a Hedera network
const txResponse = await signTx.execute(client);

//Get the receipt of the transaction
const receipt = await txResponse.getReceipt(client);

//Get the token ID from the receipt
const tokenId = receipt.tokenId;

console.log("The new token ID is " + tokenId);

//v2.0.5

Go

//Create the transaction and freeze the unsigned transaction
tokenCreateTransaction, err := hedera.NewTokenCreateTransaction().
      SetTokenName("Your Token Name").
        SetTokenSymbol("F").
        SetTreasuryAccountID(treasuryAccountId).
        SetInitialSupply(1000).
        SetAdminKey(adminKey).
        SetMetadataKey(metadataKey).
        SetMetadata(metadata)
        SetMaxTransactionFee(hedera.NewHbar(30)). //Change the default max transaction fee
        FreezeWith(client)

if err != nil {
    panic(err)
}

//Sign with the admin private key of the token, sign with the token treasury private key, sign with the client operator private key and submit the transaction to a Hedera network
txResponse, err := tokenCreateTransaction.Sign(adminKey).Sign(treasuryKey).Execute(client)

if err != nil {
    panic(err)
}

//Request the receipt of the transaction
receipt, err := txResponse.GetReceipt(client)
if err != nil {
    panic(err)
}

//Get the token ID from the receipt
tokenId := *receipt.TokenID

fmt.Printf("The new token ID is %v\n", tokenId)

//v2.1.0

Rust

// Create the transaction
let transaction = TokenCreateTransaction::new()
    .name("Your Token Name")
    .symbol("F")
    .treasury_account_id(treasury_account_id)
    .initial_supply(5000)
    .admin_key(admin_key.public_key())
    .metadata_key(metadata_key)
    .metadata(metadata)
    .max_transaction_fee(Hbar::from(30)); // Change the default max transaction fee

// Build the unsigned transaction, sign with admin private key of the token, sign with the token treasury private key
let tx_response = transaction
    .freeze_with(&client)?
    .sign(admin_key)
    .sign(treasury_key)
    .execute(&client).await?;

// Request the receipt of the transaction
let receipt = tx_response.get_receipt(&client).await?;

// Get the token ID from the receipt
let token_id = receipt.token_id.unwrap();

println!("The new token ID is {:?}", token_id);

// v0.34.0