Create an account

Create an account using the account create API

A transaction that creates a Hedera account. A Hedera account is required to interact with any of the Hedera network services as you need an account to pay for all associated transaction/query fees. You can visit the Hedera Developer Portal to create a previewnet or testnet account. You can also use third-party wallets to generate free mainnet accounts. To process an account create transaction, you will need an existing account to pay for the transaction fee. To obtain the new account ID, request the receipt of the transaction.

When creating a new account using theAccountCreateTransaction()API you will need an existing account to pay for the associated transaction fee.

Account Properties

Account Properties

Transaction Fees

The sender pays for the token association fee and the rent for the first auto-renewal period.
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.

Transaction Signing Requirements

The account paying for the transaction fee is required to sign the transaction.

Maximum Auto-Associations and Fees

Accounts have a property, maxAutoAssociations, and the property’s value determines the maximum number of automatic token associations allowed.

Property Value	Description
`0`	Automatic token associations or token airdrops are not allowed, and the account must be manually associated with a token. This also applies if the value is less than or equal to `usedAutoAssociations`.
`-1`	Unlimited automatic token associations are allowed, and this is the default for accounts created via auto account creation and for accounts that began as hollow accounts and are now complete. Accounts with `-1` can receive new tokens without manually associating them. The sender still pays the `maxAutoAssociations` fee and initial rent for each association.
`> 0`	If the value is a positive number (number greater than 0), the number of automatic token associations an account can have is limited to that number.

The sender pays the maxAutoAssociations fee and the rent for the first auto-renewal period for the association. This is in addition to the typical transfer fees. This ensures the receiver can receive tokens without association and makes it a smoother transfer process.

Reference: HIP-904

Methods

Method	Type	Requirement
`setKey(<key>)`	Key	Required
`setAlias(<alias>)`	EvmAddress	Optional
`setInitialBalance(<initialBalance>)`	HBar	Optional
`setReceiverSignatureRequired(<booleanValue>)`	boolean	Optional
`setMaxAutomaticTokenAssociations(<amount>)`	int	Optional
`setStakedAccountId(<stakedAccountId>)`	AccountId	Optional
`setStakedNodeId(<stakedNodeId>)`	long	Optional
`setDeclineStakingReward(<declineStakingReward>)`	boolean	Optional
`setAccountMemo(<memo>)`	String	Optional
`setAutoRenewPeriod(<autoRenewPeriod>)`	Duration	Disabled
`addHook(<hook>)`	HookCreationDetails	Optional
`setHooks(<hooks>)`	list<HookCreationDetails>	Optional

Account AliasIf an alias is set during account creation, it becomes immutable, meaning it cannot be changed. If you plan to update or rotate keys in the future, do not set the alias at the time of initial account creation. The alias can be set after finalizing all key updates.

Account Hooks (HIP-1195)You can attach Hiero Hooks to an account at creation time using addHook(). Hooks are programmable EVM extension points that let you enforce custom validation logic on transfers involving this account. See Create and Manage Hooks for full details and utility class reference.

//Create the transaction
AccountCreateTransaction transaction = new AccountCreateTransaction()
    .setKeyWithAlias(ecdsaPublicKey)
    // DO NOT set an alias with your key if you plan to update/rotate keys in the future, Use .setKeyWithoutAlias instead 
    // .setKeyWithoutAlias(ecdsaPublicKey)
    .setInitialBalance(new Hbar(1));

//Submit the transaction to a Hedera network
TransactionResponse txResponse = transaction.execute(client);

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

//Get the account ID
AccountId newAccountId = receipt.accountId;

System.out.println("The new account ID is " +newAccountId);

//Version 2.0.0

//Create new ECDSA key
const ecdsaPublicKey = PrivateKey.generateECDSA().publicKey

//Create the transaction
const transaction = new AccountCreateTransaction()
    .setKeyWithAlias(ecdsaPublicKey)
    // DO NOT set an alias with your key if you plan to update/rotate keys in the future, Use .setKeyWithoutAlias instead 
    // .setKeyWithoutAlias(ecdsaPublicKey)
    .setInitialBalance(new Hbar(1));

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

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

//Get the account ID
const newAccountId = receipt.accountId;

console.log("The new account ID is " +newAccountId);

//v2.0.5

//Create the transaction
transaction := hedera.NewAccountCreateTransaction().
        SetKeyWithAlias(ecdsaPublicKey).
        //do not set if you need to rotate keys in the future
        // SetKeyWithoutAlias(ecdsaPublicKey).
        SetInitialBalance(hedera.NewHbar(1))

//Sign the transaction with the client operator private key and submit to a Hedera network
txResponse, err := AccountCreateTransaction.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 account ID
newAccountId := *receipt.AccountID

fmt.Printf("The new account ID is %v\n", newAccountId)

//Version 2.0.0

// Create new ECDSA key
let ecdsa_public_key = PrivateKey::generate_ecdsa().public_key();

// Create the transaction
let transaction = AccountCreateTransaction::new()
    .key_with_alias(ecdsa_public_key)
    // DO NOT set an alias with your key if you plan to update/rotate keys in the future, Use .key_without_alias instead 
    // .key_without_alias(ecdsa_public_key)
    .initial_balance(Hbar::from(1));

// Sign the transaction with the client operator private key and submit to a Hedera network
let tx_response = transaction
    .execute(&client)
    .await?;

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

// Get the account ID
let new_account_id = receipt.account_id.unwrap();

println!("The new account ID is {}", new_account_id);

// v0.34.0

Create an account with an EVM hook

This example creates a new account with an account allowance hook attached. The hook contract must be deployed first via ContractCreateTransaction.

// Step 1: Deploy hook contract first (standard ContractCreateTransaction)
ContractId contractId = /* ... your deployed hook contract ... */;

// Step 2: Create the hook details
HookCreationDetails hookDetails = new HookCreationDetails(
    HookExtensionPoint.ACCOUNT_ALLOWANCE_HOOK,
    1002L,
    new EvmHook(contractId),
    adminKey.getPublicKey()
);

// Step 3: Create the account with the hook attached
TransactionResponse txResponse = new AccountCreateTransaction()
    .setKey(accountKey.getPublicKey())
    .setInitialBalance(Hbar.from(1))
    .addHook(hookDetails)
    .setMaxTransactionFee(new Hbar(10))
    .freezeWith(client)
    .sign(accountKey)
    .execute(client);

AccountId newAccountId = txResponse.getReceipt(client).accountId;
System.out.println("Account created with hook: " + newAccountId);

import {
    AccountCreateTransaction,
    HookCreationDetails,
    EvmHook,
    HookExtensionPoint,
    Hbar,
    Long,
} from "@hiero-ledger/sdk";

// Step 1: Deploy hook contract first (standard ContractCreateTransaction)
const contractId = /* ... your deployed hook contract ... */;

// Step 2: Create the hook details
const hookDetails = new HookCreationDetails({
    extensionPoint: HookExtensionPoint.ACCOUNT_ALLOWANCE_HOOK,
    hookId: Long.fromInt(1002),
    evmHook: new EvmHook({ contractId }),
    adminKey: adminKey.publicKey,
});

// Step 3: Create the account with the hook attached
const txResponse = await (
    await new AccountCreateTransaction()
        .setKeyWithoutAlias(accountKey.publicKey)
        .setInitialBalance(new Hbar(1))
        .addHook(hookDetails)
        .setMaxTransactionFee(new Hbar(10))
        .freezeWith(client)
        .sign(accountKey)
).execute(client);

const { accountId } = await txResponse.getReceipt(client);
console.log(`Account created with hook: ${accountId}`);

// Step 1: Deploy hook contract first (standard ContractCreateTransaction)
// contractId := ... your deployed hook contract ...

// Step 2: Create the hook details
hookDetails := hedera.NewHookCreationDetails().
    SetExtensionPoint(hedera.ACCOUNT_ALLOWANCE_HOOK).
    SetHookId(1002).
    SetEvmHook(*hedera.NewEvmHook().SetContractId(&contractId)).
    SetAdminKey(adminKey.PublicKey())

// Step 3: Create the account with the hook attached
txResponse, err := hedera.NewAccountCreateTransaction().
    SetKey(accountKey.PublicKey()).
    SetInitialBalance(hedera.NewHbar(1)).
    AddHook(hookDetails).
    SetMaxTransactionFee(hedera.NewHbar(10)).
    FreezeWith(client).
    Sign(accountKey).
    Execute(client)

receipt, err := txResponse.GetReceipt(client)
fmt.Printf("Account created with hook: %v\n", receipt.AccountID)

Get transaction values

Method	Type	Description
`getKey()`	Key	Returns the public key on the account
`getInitialBalance()`	Hbar	Returns the initial balance of the account
`getAutoRenewPeriod()`	Duration	Returns the auto renew period on the account
`getDeclineStakingReward()`	boolean	Returns whether or not the account declined rewards
`getStakedNodeId()`	long	Returns the node ID
`getStakedAccountId()`	AccountId	Returns the node account ID
`getReceiverSignatureRequired()`	boolean	Returns whether the receiver signature is required or not
`getHooks()`	list<HookCreationDetails>	Returns the hooks to be created with the account

//Create an account with 1 hbar
AccountCreateTransaction transaction = new AccountCreateTransaction()
    // The only _required_ property here is `key`
    .setKeyWithAlias(newPublicKey)
    // DO NOT set an alias with your key if you plan to update/rotate keys in the future, Use .setKeyWithoutAlias instead 
    // .setKeyWithoutAlias(newPublicKey)
    .setInitialBalance(new Hbar(1));

//Return the key on the account
Key accountKey = transaction.getKey();

//Create an account with 1 HBAR 
const transaction = new AccountCreateTransaction()
    // The only _required_ property here is `key`
    .setKeyWithAlias(newPublicKey)
    // Do NOT set an alias if you need to rotate keys in the future. Use .setKeyWithoutAlias instead
    // .setKeyWithoutAlias(newPublicKey)
    .setInitialBalance(new Hbar(1));

//Return the key on the account
const accountKey = transaction.getKey();

//Create an account with 1 hbar
AccountCreateTransaction := hedera.NewAccountCreateTransaction().
    SetKeyWithAlias(newPublicKey).
    // DO NOT set an alias with your key if you plan to update/rotate keys in the future, Use .SetKeyWithoutAlias instead 
    // SetKeyWithoutAlias(newPublicKey).
    SetInitialBalance(hedera.NewHbar(1))

//Return the key on the account
accountKey, err := AccountCreateTransaction.GetKey()