> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hedera.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Associate tokens to an account

Associates the provided Hedera account with the provided Hedera token(s). Hedera accounts must be associated with a fungible or non-fungible token first before you can transfer tokens to that account. When you transfer a custom fungible or non-fungible token to the alias account ID, the token association step is skipped and the account will automatically be associated with the token upon creation. In the case of NON\_FUNGIBLE **Type**, once an account is associated, it can hold any number of NFTs (serial numbers) of that token type. The Hedera account that is associated with a token is required to sign the transaction.

* If the provided account is not found, the transaction will resolve to `INVALID_ACCOUNT_ID`.
* If the provided account has been deleted, the transaction will resolve to `ACCOUNT_DELETED`.
* If any of the provided tokens is not found, the transaction will resolve to `INVALID_TOKEN_REF`.
* If any of the provided tokens has been deleted, the transaction will resolve to `TOKEN_WAS_DELETED`.
* If an association between the provided account and any of the tokens already exists, the transaction will resolve to `TOKEN_ALREADY_ASSOCIATED_TO_ACCOUNT`.
* If the provided account's associations count exceeds the constraint of maximum token associations per account, the transaction will resolve to `TOKENS_PER_ACCOUNT_LIMIT_EXCEEDED`.
* On success, associations between the provided account and tokens are made and the account is ready to interact with the tokens.

<Info>
  There is currently no limit on the number of token IDs that can be associated with an account (reference [HIP-367](https://hips.hedera.com/hip/hip-367)). Still, you can see `TOKENS_PER_ACCOUNT_LIMIT_EXCEEDED` responses for *pre-HIP-367* transactions.
</Info>

**Transaction Signing Requirements**

* The key of the account the token is being associated to
* Transaction fee payer account key

**Transaction Fees**

* Please see the transaction and query [fees](/learn/networks/mainnet/fees#transaction-and-query-fees) table for the base transaction fee
* Please use the [Hedera fee estimator](https://hedera.com/fees) to estimate your transaction fee cost

## Constructor

| Constructor                       | Description                                      |
| --------------------------------- | ------------------------------------------------ |
| `new TokenAssociateTransaction()` | Initializes the TokenAssociateTransaction object |

## Transaction Properties

| Method                        | **Type**       | Requirement |
| ----------------------------- | -------------- | ----------- |
| `setAccountId(<accountId>)`   | AccountId      | Required    |
| `setTokenIds(<tokenIds>)`     | List\<TokenId> | Required    |
| `setHighVolume(<highVolume>)` | boolean        | Optional    |

## Get Transaction Values

| Method            | **Type**       | Description                                                                                                                                   |
| ----------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `getAccountId()`  | AccountId      | Returns the account to be associated                                                                                                          |
| `getTokenIds()`   | List\<TokenId> | Returns the list of tokens to be associated                                                                                                   |
| `getHighVolume()` | boolean        | Returns whether this transaction uses [high-volume throttles](/learn/core-concepts/high-volume-entity-creation#high-volume-throttle-capacity) |

<Note>
  This transaction supports [high-volume entity creation](/learn/core-concepts/high-volume-entity-creation)
  (HIP-1313). Setting `setHighVolume(true)` routes the transaction through dedicated
  high-volume throttle capacity with variable-rate pricing for both fungible and NFT mints.
  Always pair this with `setMaxTransactionFee()` to cap your costs.
</Note>

<CodeGroup>
  ```java Java theme={null}
  //Associate a token to an account
  TokenAssociateTransaction transaction = new TokenAssociateTransaction()
          .setAccountId(accountId)
          .setTokenIds(Collections.singletonList(tokenId));

  //Freeze the unsigned transaction, sign with the private key of the account that is being associated to a token, submit the transaction to a Hedera network
  TransactionResponse txResponse = transaction.freezeWith(client).sign(accountKey).execute(client);

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

  //Get the transaction consensus status
  Status transactionStatus = receipt.status;

  System.out.println("The transaction consensus status " +transactionStatus);
  //v2.0.4
  ```

  ```javascript JavaScript theme={null}
  //Associate a token to an account and freeze the unsigned transaction for signing
  const transaction = await new TokenAssociateTransaction()
       .setAccountId(accountId)
       .setTokenIds([tokenId])
       .freezeWith(client);

  //Sign with the private key of the account that is being associated to a token 
  const signTx = await transaction.sign(accountKey);

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

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

  //Get the transaction consensus status
  const transactionStatus = receipt.status;

  console.log("The transaction consensus status " +transactionStatus.toString());

  //v2.0.7
  ```

  ```go Go theme={null}
  //Associate the token to an account and freeze the unsigned transaction for signing
  transaction, err := hedera.NewTokenAssociateTransaction().
          SetAccountID(accountId).
          SetTokenIDs(tokenId).
          FreezeWith(client)

  if err != nil {
      panic(err)
  }

  //Sign with the private key of the account that is being associated to a token, submit the transaction to a Hedera network
  txResponse, err = transaction.Sign(accountKey).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 transaction consensus status
  status := receipt.Status

  fmt.Printf("The transaction consensus status is %v\n", status)

  //v2.1.0
  ```

  ```rust Rust theme={null}
  // Associate a token to an account
  let transaction = TokenAssociateTransaction::new()
      .account_id(account_id)
      .token_ids(vec![token_id]);

  // Freeze the unsigned transaction, sign with the private key of the account
  let tx_response = transaction
      .freeze_with(&client)?
      .sign(account_key)
      .execute(&client).await?;

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

  // Get the transaction consensus status
  let status = receipt.status;

  println!("The transaction consensus status is {:?}", status);

  // v0.34.0
  ```
</CodeGroup>