> ## 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.

# Create Your First Frictionless Airdrop Campaign

> Run a Hedera Frictionless Airdrop with TokenAirdropTransaction, TokenClaimAirdropTransaction, and TokenCancelAirdropTransaction to distribute tokens at scale.

## Summary

In this tutorial, we’ll guide you through Hedera’s **Frictionless Airdrop** flow, which streamlines token distribution while giving recipients greater control over the tokens they receive. Throughout the tutorial, you’ll work with four new transaction types designed to simplify the airdrop process and safeguard users' token holdings. Each transaction type plays a unique role in enabling frictionless, user-friendly airdrops.

Before diving into the step-by-step guide, here’s a quick overview of the transaction types you’ll encounter:

* [**TokenAirdropTransaction**](/native/tokens/airdrop): This transaction allows you to distribute tokens to multiple recipients in a single transaction, even if the receiving accounts haven’t pre-associated with the token. It also supports pending transfers when accounts don’t have the necessary token associations.
* [**TokenClaimAirdropTransaction**](/native/tokens/claim): When a **recipient** doesn’t have available token associations, this transaction allows them to claim their tokens from a pending airdrop, ensuring full control over which tokens they want to accept.
* [**TokenRejectTransaction**](/native/tokens/reject-airdrop): If a user **receives** unwanted tokens, they can use this transaction to transfer them back to the token’s treasury without incurring any custom fees or royalties.
* [**TokenCancelAirdropTransaction**](/native/tokens/cancel): This transaction allows the **sender** to cancel a pending airdrop if the recipient hasn’t claimed it yet. It gives the sender flexibility to manage unclaimed token transfers.

Now that we have a basic understanding of the transaction types, let’s move on to the step-by-step implementation of a Frictionless Airdrop on Hedera. The full code solution is provided at the end of the tutorial if you want to see it.

***

## Prerequisites

We recommend you complete the following introduction to get a basic understanding of Hedera transactions. This example does not build upon the previous examples.

* Get a [Hedera testnet account](/native/tutorials/getting-started/create-fund-account).
* Set up your environment [here](/native).
* `.env` file with this additional variable added:
  ```highlight={1} theme={null}
  HEDERA_NETWORK=testnet
  ```

***

In this tutorial, we would like to airdrop a fungible token, "GameGold," and a non-fungible token to our gaming community. We would like to send an equal amount of tokens to the top three players in our community without them knowing about the upcoming airdrop. Let's learn!

### Step 1: Setup and Account Creation

First, we need to create the three accounts that will receive our airdrop and a treasury account. Each account will have a different configuration for automatic token association slots:

* **Alice:** Unlimited token association slots by setting the value to `-1` which means she can receive as many tokens as she wants, and they will be automatically associated with her account.
* **Bob:** Only has 1 free token association slot.
* **Charlie:** Has no free token association slots.
* **Treasury**: This account will send the airdrop as it controls the treasury of our token collections.

The setup code imports the required functions from the Hedera SDK and the `dotenv` package to load the required environment variables. Further, it creates the accounts for Alice, Bob, and Charlie.

<CodeGroup>
  ```javascript JavaScript theme={null}
  import {
      Client, PrivateKey, AccountId, AccountCreateTransaction, Hbar, NftId,
      TokenCreateTransaction, TokenType, TokenMintTransaction, AccountBalanceQuery,
      TokenAirdropTransaction,
      TokenClaimAirdropTransaction,
      TokenCancelAirdropTransaction,
      TokenRejectTransaction,
  } from "@hashgraph/sdk";

  import dotenv from "dotenv";
  dotenv.config();

  async function main() {
      if (
          process.env.OPERATOR_ID == null ||
          process.env.OPERATOR_KEY == null ||
          process.env.HEDERA_NETWORK == null
      ) {
          throw new Error(
              "Environment variables OPERATOR_ID, HEDERA_NETWORK, and OPERATOR_KEY are required.",
          );
      }

      const client = Client.forName(process.env.HEDERA_NETWORK).setOperator(
          AccountId.fromString(process.env.OPERATOR_ID),
          PrivateKey.fromStringDer(process.env.OPERATOR_KEY),
      );

      /**
       * Step 1: Create 4 accounts
       */
      const alicePrivateKey = PrivateKey.generateECDSA();
      const alicePublicKey = alicePrivateKey.publicKey;
      const { accountId: aliceId } = await (
          await new AccountCreateTransaction()
              .setKey(alicePublicKey)
              //Do NOT set an alias if you need to update/rotate keys in the future
              .setAlias(alicePublicKey.toEvmAddress())
              .setInitialBalance(new Hbar(10))
              .setMaxAutomaticTokenAssociations(-1) // unlimited associations
              .execute(client)
      ).getReceipt(client);

      const bobPrivateKey = PrivateKey.generateECDSA();
      const bobPublicKey = bobPrivateKey.publicKey;
      const { accountId: bobId } = await (
          await new AccountCreateTransaction()
              .setKey(bobPublicKey)
              //Do NOT set an alias if you need to update/rotate keys in the future
              .setAlias(bobPublicKey.toEvmAddress())
              .setInitialBalance(new Hbar(10))
              .setMaxAutomaticTokenAssociations(1) // 1 association
              .execute(client)
      ).getReceipt(client);


      const charliePrivateKey = PrivateKey.generateECDSA();
      const charliePublicKey = charliePrivateKey.publicKey;
      const { accountId: charlieId } = await (
          await new AccountCreateTransaction()
              .setKey(charliePublicKey)
              //Do NOT set an alias if you need to update/rotate keys in the future
              .setAlias(charliePublicKey.toEvmAddress())
              .setInitialBalance(new Hbar(10))
              .setMaxAutomaticTokenAssociations(0) // no association slots
              .execute(client)
      ).getReceipt(client);

      // treasury account for tokens
      const treasuryKey = PrivateKey.generateECDSA();
      const treasuryPublicKey = treasuryKey.publicKey;
      const { accountId: treasuryAccount } = await (
          await new AccountCreateTransaction()
              .setKey(treasuryPublicKey)
              //Do NOT set an alias if you need to update/rotate keys in the future
              .setAlias(treasuryPublicKey.toEvmAddress()
              .setInitialBalance(new Hbar(10))
              .setMaxAutomaticTokenAssociations(-1)
              .execute(client)
      ).getReceipt(client);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"log"
  	"os"
  	"time"

  	hedera "github.com/hiero-ledger/hiero-sdk-go/v2/sdk"
  	"github.com/joho/godotenv"
  )

  func main() {
  	err := godotenv.Load(".env")
  	if err != nil {
  		panic(fmt.Errorf("Unable to load environment variables from .env file. Error:n%v\n", err))
  	}

  	operatorId, err := hedera.AccountIDFromString(os.Getenv("OPERATOR_ID"))
  	if err != nil {
  		panic(err)
  	}

  	operatorKey, err := hedera.PrivateKeyFromString(os.Getenv("OPERATOR_KEY"))
  	if err != nil {
  		panic(err)
  	}

  	client := hedera.ClientForTestnet()
  	client.SetOperator(operatorId, operatorKey)
  	client.SetDefaultMaxTransactionFee(hedera.HbarFrom(100, hedera.HbarUnits.Hbar))
  	client.SetDefaultMaxQueryPayment(hedera.HbarFrom(50, hedera.HbarUnits.Hbar))

  	// Step 1: Create 4 accounts
  	alicePrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
  	if err != nil {
  		log.Fatalf("Error generating private key for Alice: %v", err)
  	}
  	aliceId := createAccount(client, alicePrivateKey, 10, -1) // Unlimited associations

  	bobPrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
  	if err != nil {
  		log.Fatalf("Error generating private key for Bob: %v", err)
  	}
  	bobId := createAccount(client, bobPrivateKey, 10, 1) // 1 association

  	charliePrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
  	if err != nil {
  		log.Fatalf("Error generating private key for Charlie: %v", err)
  	}
  	charlieId := createAccount(client, charliePrivateKey, 10, 0) // No associations

  	treasuryPrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
  	if err != nil {
  		log.Fatalf("Error generating private key for Treasury: %v", err)
  	}
  	treasuryAccount := createAccount(client, treasuryPrivateKey, 10, -1) // Unlimited associations

  	fmt.Printf("Alice Account ID: %v\n", aliceId)
  	fmt.Printf("Bob Account ID: %v\n", bobId)
  	fmt.Printf("Charlie Account ID: %v\n", charlieId)
  	fmt.Printf("Treasury Account ID: %v\n", treasuryAccount)
  	// ...
  }

  // Helper function to generate a new Hedera account
  func createAccount(client *hedera.Client, newAccountPrivateKey hedera.PrivateKey, initialBalance float64, maxAssociations int32) hedera.AccountID {
  	newAccountPublicKey := newAccountPrivateKey.PublicKey()

  	// Create the new account with the generated public key
  	newAccountTx, err := hedera.NewAccountCreateTransaction().
  		SetKey(newAccountPublicKey).
  		SetInitialBalance(hedera.HbarFrom(initialBalance, hedera.HbarUnits.Hbar)).
  		SetMaxAutomaticTokenAssociations(maxAssociations).
  		Execute(client)

  	if err != nil {
  		log.Fatalf("Error creating new account: %v", err)
  	}

  	receipt, err := newAccountTx.GetReceipt(client)
  	if err != nil {
  		log.Fatalf("Error getting receipt for account creation: %v", err)
  	}

  	newAccountId := *receipt.AccountID

  	return newAccountId
  }
  ```
</CodeGroup>

### Step 2: Create a New Token

Let's create a new token called "GameGold" that we will airdrop to our gaming community. We’ll mint `300` tokens in total and distribute them equally among our top three players, Alice, Bob, and Charlie, with each player receiving `100` tokens.

<CodeGroup>
  ```javascript JavaScript highlight={5} theme={null}
  /**
   * Step 2: Create FT and NFT mint
   */
  const INITIAL_SUPPLY = 300;
  const tokenCreateTx = await new TokenCreateTransaction()
    .setTokenName("GameGold")
    .setTokenSymbol("GG")
    .setDecimals(3)
    .setInitialSupply(INITIAL_SUPPLY)
    .setTreasuryAccountId(treasuryAccount)
    .setAdminKey(client.operatorPublicKey)
    .setFreezeKey(client.operatorPublicKey)
    .setSupplyKey(client.operatorPublicKey)
    .setMetadataKey(client.operatorPublicKey)
    .setPauseKey(client.operatorPublicKey)
    .freezeWith(client)
    .sign(treasuryKey);

  const { tokenId } = await (
    await tokenCreateTx.execute(client)
  ).getReceipt(client);
  ```

  ```go Go theme={null}
  	// Step 2: Create FT and mint
  	tokenCreateTx, err := hedera.NewTokenCreateTransaction().
  		SetTokenName("GameGold").
  		SetTokenSymbol("GG").
  		SetDecimals(3).
  		SetInitialSupply(300).
  		SetTreasuryAccountID(treasuryAccount).
  		SetAdminKey(client.GetOperatorPublicKey()).
  		SetFreezeKey(client.GetOperatorPublicKey()).
  		SetSupplyKey(client.GetOperatorPublicKey()).
  		SetMetadataKey(client.GetOperatorPublicKey()).
  		FreezeWith(client)

  	if err != nil {
  		log.Fatalf("Error creating fungible token transaction: %v", err)
  	}

  	tokenCreateTxSigned := tokenCreateTx.Sign(treasuryPrivateKey)
  	tokenCreateTxReceipt, err := tokenCreateTxSigned.Execute(client)
  	if err != nil {
  		log.Fatalf("Error executing fungible token transaction: %v", err)
  	}

  	receipt, err := tokenCreateTxReceipt.GetReceipt(client)
  	if err != nil {
  		log.Fatalf("Error getting receipt for fungible token: %v", err)
  	}

  	tokenId := *receipt.TokenID
  	fmt.Printf("Created fungible token with ID: %v\n", tokenId.String())
  ```
</CodeGroup>

### Step 3: Airdrop Tokens with Frictionless Airdrop

Ok, we are ready to airdrop the `GameGold` token to the top 3 players Alice, Bob, and Charlie. Each of them receives 100 tokens. The code should print one pending airdrop for Charlie because Alice and Bob had free token association slots. Only Charlie didn't have any free slots, so he had to claim the token himself.

<CodeGroup>
  ```javascript JavaScript highlight={7} theme={null}
  /**
   * Step 3: Airdrop fungible tokens to 3 accounts
   */
  const AIRDROP_SUPPLY_PER_ACCOUNT = INITIAL_SUPPLY / 3;
  const airdropRecord = await (
    await (
      await new TokenAirdropTransaction()
        .addTokenTransfer(tokenId, treasuryAccount, -AIRDROP_SUPPLY_PER_ACCOUNT)
        .addTokenTransfer(tokenId, aliceId, AIRDROP_SUPPLY_PER_ACCOUNT)
        .addTokenTransfer(tokenId, treasuryAccount, -AIRDROP_SUPPLY_PER_ACCOUNT)
        .addTokenTransfer(tokenId, bobId, AIRDROP_SUPPLY_PER_ACCOUNT)
        .addTokenTransfer(tokenId, treasuryAccount, -AIRDROP_SUPPLY_PER_ACCOUNT)
        .addTokenTransfer(tokenId, charlieId, AIRDROP_SUPPLY_PER_ACCOUNT)
        .freezeWith(client)
        .sign(treasuryKey)
    ).execute(client)
  ).getRecord(client);

  // Get the transaction record and see the pending airdrops
  const { newPendingAirdrops } = airdropRecord;
  console.log("Pending airdrop", newPendingAirdrops[0]);

  // Query to verify Alice and Bob have received the airdrops and Charlie has not
  let aliceBalance = await new AccountBalanceQuery()
    .setAccountId(aliceId)
    .execute(client);

  let bobBalance = await new AccountBalanceQuery()
    .setAccountId(bobId)
    .execute(client);

  let charlieBalance = await new AccountBalanceQuery()
    .setAccountId(charlieId)
    .execute(client);

  console.log(
    "Alice balance after airdrop: ",
    aliceBalance.tokens.get(tokenId).toInt()
  );
  console.log(
    "Bob balance after airdrop: ",
    bobBalance.tokens.get(tokenId).toInt()
  );
  console.log(
    "Charlie balance after airdrop: ",
    charlieBalance.tokens.get(tokenId)
  );
  ```

  ```go Go theme={null}
  	// Step 3: Airdrop 100 tokens each to 3 accounts
  	airdropTx, err := hedera.NewTokenAirdropTransaction().
  		AddTokenTransfer(tokenId, treasuryAccount, -100).
  		AddTokenTransfer(tokenId, aliceId, 100).
  		AddTokenTransfer(tokenId, treasuryAccount, -100).
  		AddTokenTransfer(tokenId, bobId, 100).
  		AddTokenTransfer(tokenId, treasuryAccount, -100).
  		AddTokenTransfer(tokenId, charlieId, 100).
  		FreezeWith(client)
  	if err != nil {
  		log.Fatalf("Error creating token airdrop transaction: %v", err)
  	}

  	airdropTxSigned := airdropTx.Sign(treasuryPrivateKey)
  	airdropTxReceipt, err := airdropTxSigned.Execute(client)
  	if err != nil {
  		log.Fatalf("Error executing token airdrop transaction: %v", err)
  	}
  	airdropTxRecord, err := airdropTxReceipt.GetRecord(client)
  	if err != nil {
  		log.Fatalf("Error getting record for token airdrop transaction: %v", err)
  	}
  	fmt.Println("Pending airdrop: ", airdropTxRecord.PendingAirdropRecords[0].String())
  	fmt.Println("Airdropped fungible tokens")

  	aliceBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(aliceId).Execute(client)
  	fmt.Println("Alice's balance: ", aliceBalance.Tokens.Get(tokenId))
  	bobBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(bobId).Execute(client)
  	fmt.Println("Bob's balance: ", bobBalance.Tokens.Get(tokenId))
  	charlieBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
  	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))
  ```
</CodeGroup>

The output we expect here is that Alice and Bob have received 100 units of our token, and the balance for Charlie shows `null`.

### Step 4: Charlie Claims the Airdrop

Alright, Charlie still needs to claim his tokens. Let's do this first using the `TokenClaimAirdropTransaction` and verify its balance to ensure he has received the 100 units of our `GameGold` token.

<CodeGroup>
  ```javascript JavaScript highlight={5} theme={null}
  /**
   * Step 4: Claim the airdrop for Charlie's account
   */
  console.log("Pending airdrop ID: ", newPendingAirdrops[0].airdropId);
  const tokenClaimTx = await new TokenClaimAirdropTransaction()
    .addPendingAirdropId(newPendingAirdrops[0].airdropId)
    .freezeWith(client)
    .sign(charliePrivateKey);
  const tokenClaimTxResponse = await tokenClaimTx.execute(client);
  const tokenClaimTxReceipt = await tokenClaimTxResponse.getReceipt(client);

  console.log(
    `Status of token claim airdrop transaction: ${tokenClaimTxReceipt.status.toString()}`
  );

  const charlieBalanceAfterClaim = await new AccountBalanceQuery()
    .setAccountId(charlieId)
    .execute(client);

  console.log(
    "Charlie balance after airdrop claim",
    charlieBalanceAfterClaim.tokens.get(tokenId).toInt()
  );
  ```

  ```go Go theme={null}
  	// Step 4: Claim the airdrop for Charlie's account
  	tokenClaimTx, err := hedera.NewTokenClaimAirdropTransaction().AddPendingAirdropId(airdropTxRecord.PendingAirdropRecords[0].GetPendingAirdropId()).FreezeWith(client)
  	if err != nil {
  		log.Fatalf("Error creating token claim airdrop transaction: %v", err)
  	}
  	tokenClaimTxSigned := tokenClaimTx.Sign(charliePrivateKey)

  	_, err = tokenClaimTxSigned.Execute(client)
  	if err != nil {
  		log.Fatalf("Error executing token claim airdrop transaction: %v", err)
  	}
  	fmt.Println("Claimed airdrop for Charlie's account")
  	time.Sleep(4 * time.Second)
  	charlieBalance, _ = hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
  	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))
  ```
</CodeGroup>

### Step 5: Airdrop NFTs to Alice, Bob, and Charlie

We would like to airdrop Game NFTs to Alice, Bob, and Charlie in this step. Bob has already used his free association slot, and Charlie also doesn't have any free association slots. This part of the tutorial will teach you how to use the `TokenCancelAirdropTransaction` and `TokenRejectTransaction`.

First, we need to create the NFT collection and mint new NFts. Then, we can airdrop the NFTs. Two pending airdrops should be created for Bob and Charlie as they don't have free auto association slots available.

<CodeGroup>
  ```javascript JavaScript highlight={1} theme={null}
      /**
       * Step 5: Airdrop the NFTs to Alice, Bob, and Charlie
       */
     const CID = [
          "QmNPCiNA3Dsu3K5FxDPMG5Q3fZRwVTg14EXA92uqEeSRXn",
          "QmZ4dgAgt8owvnULxnKxNe8YqpavtVCXmc1Lt2XajFpJs9",
          "QmPzY5GxevjyfMUF5vEAjtyRoigzWp47MiKAtLBduLMC1T",
          "Qmd3kGgSrAwwSrhesYcY7K54f3qD7MDo38r7Po2dChtQx5",
          "QmWgkKz3ozgqtnvbCLeh7EaR1H8u5Sshx3ZJzxkcrT3jbw",
      ];
      
      // Create Game NFT
      const { tokenId: nftId } = await (
          await (
              await new TokenCreateTransaction()
                  .setTokenName("Game NFT")
                  .setTokenSymbol("GNFT")
                  .setTokenType(TokenType.NonFungibleUnique)
                  .setTreasuryAccountId(treasuryAccount)
                  .setAdminKey(client.operatorPublicKey)
                  .setFreezeKey(client.operatorPublicKey)
                  .setSupplyKey(client.operatorPublicKey)
                  .setMetadataKey(client.operatorPublicKey)
                  .setPauseKey(client.operatorPublicKey)
                  .freezeWith(client)
                  .sign(treasuryKey)
          ).execute(client)
      ).getReceipt(client);

      let serialsNfts = [];
      for (let i = 0; i < CID.length; i++) {
          const { serials } = await (
              await new TokenMintTransaction()
                  .setTokenId(nftId)
                  .addMetadata(Buffer.from("-"))
                  .execute(client)
          ).getReceipt(client);

          serialsNfts.push(serials[0]);
      }

      // Airdrop NFTs
      const { newPendingAirdrops: newPendingAirdropsNfts } = await (
          await (
              await new TokenAirdropTransaction()
                  .addNftTransfer(
                      nftId,
                      serialsNfts[0],
                      treasuryAccount,
                      aliceId,
                  )
                  .addNftTransfer(
                      nftId,
                      serialsNfts[1],
                      treasuryAccount,
                      bobId,
                  )
                  .addNftTransfer(
                      nftId,
                      serialsNfts[2],
                      treasuryAccount,
                      charlieId,
                  )
                  .freezeWith(client)
                  .sign(treasuryKey)
          ).execute(client)
      ).getRecord(client);

      // Get the tx record and verify two pending airdrops (for Bob and Charlie)
      console.log("Pending airdrops length", newPendingAirdropsNfts.length);
      console.log("Pending airdrop for Bob:", newPendingAirdropsNfts[0]);
      console.log("Pending airdrop for Charlie:", newPendingAirdropsNfts[1]);

  ```

  ```go Go theme={null}
  	// Step 5: Airdrop the NFTs to Alice, Bob, and Charlie
  	CID := [][]byte{
  		[]byte("ipfs://bafyreiao6ajgsfji6qsgbqwdtjdu5gmul7tv2v3pd6kjgcw5o65b2ogst4/metadata.json"),
  		[]byte("ipfs://bafyreic463uarchq4mlufp7pvfkfut7zeqsqmn3b2x3jjxwcjqx6b5pk7q/metadata.json"),
  		[]byte("ipfs://bafyreihhja55q6h2rijscl3gra7a3ntiroyglz45z5wlyxdzs6kjh2dinu/metadata.json"),
  		[]byte("ipfs://bafyreidb23oehkttjbff3gdi4vz7mjijcxjyxadwg32pngod4huozcwphu/metadata.json"),
  		[]byte("ipfs://bafyreie7ftl6erd5etz5gscfwfiwjmht3b52cevdrf7hjwxx5ddns7zneu/metadata.json"),
  	}
  	nftCreate, err := hedera.NewTokenCreateTransaction().
  		SetTokenName("Game NFT").
  		SetTokenSymbol("GNFT").
  		SetTokenType(hedera.TokenTypeNonFungibleUnique).
  		SetTreasuryAccountID(treasuryAccount).
  		SetSupplyKey(client.GetOperatorPublicKey()).
  		SetAdminKey(client.GetOperatorPublicKey()).
  		FreezeWith(client)

  	nftCreateTxSign := nftCreate.Sign(treasuryPrivateKey)
  	nftCreateSubmit, err := nftCreateTxSign.Execute(client)
  	if err != nil {
  		log.Fatalf("Error creating NFT: %v", err)
  	}

  	nftCreateReceipt, err := nftCreateSubmit.GetReceipt(client)
  	if err != nil {
  		log.Fatalf("Error getting receipt for NFT creation: %v", err)
  	}

  	fmt.Println("Created NFT with ID: 0.0.", nftCreateReceipt.TokenID.Token)
  	nftId := *nftCreateReceipt.TokenID
  	var serialsNfts []int64
  	mintTx, _ := hedera.NewTokenMintTransaction().
  		SetTokenID(nftId).
  		SetMetadatas(CID).
  		FreezeWith(client)
  	mintTxSign := mintTx.Sign(treasuryPrivateKey)
  	mintTxSubmit, err := mintTxSign.Execute(client)
  	if err != nil {
  		log.Fatalf("Error minting NFTs: %v", err)
  	}
  	mintTxReceipt, err := mintTxSubmit.GetReceipt(client)
  	if err != nil {
  		log.Fatalf("Error getting receipt for NFT minting: %v", err)
  	}
  	serialsNfts = mintTxReceipt.SerialNumbers
  	fmt.Printf("Minted NFT serial numbers: %v\n", serialsNfts)

  	// Airdrop NFTs
  	nftAirdropTx, err := hedera.NewTokenAirdropTransaction().
  		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 1}, treasuryAccount, aliceId).
  		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 2}, treasuryAccount, bobId).
  		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 3}, treasuryAccount, charlieId).
  		FreezeWith(client)
  	if err != nil {
  		log.Fatalf("Error creating NFT airdrop transaction: %v", err)
  	}

  	nftAirdropTxSigned := nftAirdropTx.Sign(treasuryPrivateKey)
  	nftAirdropTxSubmit, err := nftAirdropTxSigned.Execute(client)
  	if err != nil {
  		log.Fatalf("Error executing NFT airdrop transaction: %v", err)
  	}
  	nftAirdropTxRecord, err := nftAirdropTxSubmit.GetRecord(client)
  	if err != nil {
  		log.Fatalf("Error getting record for NFT airdrop transaction: %v", err)
  	}
  	fmt.Println("Pending airdrops length: ", len(nftAirdropTxRecord.PendingAirdropRecords))
  	fmt.Println("Pending airdrop for Bob: ", nftAirdropTxRecord.PendingAirdropRecords[0].String())
  	fmt.Println("Pending airdrop for Charlie: ", nftAirdropTxRecord.PendingAirdropRecords[1].String())
  ```
</CodeGroup>

### Step 6: Cancel Airdrop for Charlie

When airdropping the NFTs, we realized we made a mistake: Charlie is not actually our third-best player, but Greg is. To fix this, we need to cancel the pending airdrop to Charlie so that the NFT returns to our treasury account. Once the NFT is back, we can airdrop it to Greg, who is the rightful recipient. Let's learn how to use the `TokenCancelAirdropTransaction` to cancel an airdrop for a specific account.

<CodeGroup>
  ```javascript JavaScript highlight={5} theme={null}
      /**
       * Step 6: Cancel the airdrop for Charlie
       * No signature is needed as the operator account is the admin of the token
       */
      await new TokenCancelAirdropTransaction()
          .addPendingAirdropId(newPendingAirdropsNfts[1].airdropId) // Charlie's airdrop
          .execute(client);

  ```

  ```go Go highlight={1} theme={null}
  	// Step 6: Cancel Airdrop for Charlie
  	hedera.NewTokenCancelAirdropTransaction().
  		AddPendingAirdropId(nftAirdropTxRecord.PendingAirdropRecords[1].GetPendingAirdropId()).
  		Execute(client)

  ```
</CodeGroup>

### Step 7: Token Reject Already Received Airdrop

And lastly, as Charlie is not the rightful owner of the received fungible token, we've asked him if he wants to return the 100 units of our `GameGold` token. Charlie has agreed and can return the token without paying any fees or royalties using the `TokenRejectTransaction`.

<Check>
  The `reject` functionality can be used to return an already claimed or a
  successful airdrop into your account. It can't be used to reject a pending
  airdrop.
</Check>

Here's the code for step 7. The rejected `GameGold` tokens will be returned to the treasury account.

<CodeGroup>
  ```javascript JavaScript highlight={6} theme={null}
      /**
       * Step 7: Reject the fungible tokens for Charlie
       */
      await (
          await (
              await new TokenRejectTransaction()
                  .setOwnerId(charlieId)
                  .addTokenId(tokenId)
                  .freezeWith(client)
                  .sign(charliePrivateKey)
          ).execute(client)
      ).getReceipt(client);

      charlieBalance = await new AccountBalanceQuery()
          .setAccountId(charlieId)
          .execute(client);

      console.log(
          "Charlie's balance after reject: ",
          charlieBalance.tokens.get(tokenId).toInt(),
      );

      client.close();

  }

  void main();

  ```

  ```go Go theme={null}
  	// Step 7: Reject the fungible tokens for Charlie
  	tokenRejectTx, err := hedera.NewTokenRejectTransaction().
  		AddTokenID(tokenId).
  		SetOwnerID(charlieId).
  		FreezeWith(client)
  	if err != nil {
  		log.Fatalf("Error creating token reject transaction: %v", err)
  	}
  	tokenRejectTxSigned := tokenRejectTx.Sign(charliePrivateKey)
  	_, err = tokenRejectTxSigned.Execute(client)
  	if err != nil {
  		log.Fatalf("Error executing token reject transaction: %v", err)
  	}
  	fmt.Println("Rejected fungible tokens for Charlie")

  	time.Sleep(4 * time.Second)
  	charlieBalance, _ = hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
  	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))
  	client.Close()
  }
  ```
</CodeGroup>

And that's it. The next section examines the fees for each of the parties involved a bit more thoroughly.

### Concluding Notes on Transaction Costs

When working with Frictionless Airdrops on Hedera, it’s important to consider the [transaction costs ](/learn/networks/mainnet/fees#token-service)associated with each step. Here are some key points to keep in mind:

1. **TokenAirdropTransaction Costs**: The sender pays all fees for distributing tokens, including fees for token association and the first auto-renewal period for newly created associations. This makes it easier and less costly for recipients, as they don’t need to pre-associate tokens or cover those fees themselves.
2. **TokenClaimAirdropTransaction Costs**: When a recipient claims tokens from a pending airdrop, they only need to cover the transaction cost for claiming. The sender still covers token association costs, ensuring the user experience remains frictionless.
3. **TokenRejectTransaction Costs**: Rejecting unwanted tokens is free from custom fees or royalties. This ensures users can easily clean up their accounts without worrying about incurring additional costs for getting rid of spam or unwanted tokens.
4. **TokenCancelAirdropTransaction Costs**: Canceling a pending airdrop comes with a nominal fee for the sender, incentivizing mindful use of the airdrop system. It provides flexibility for managing unclaimed tokens but also discourages excessive or careless airdrops.

By understanding these costs and who is responsible for them, you can build efficient, user-friendly token distribution systems while maintaining cost efficiency for both developers and end-users.

## Code Check ✅

<AccordionGroup>
  <Accordion title=".env file example">
    ```
    OPERATOR_ID=0.0.1234
    OPERATOR_KEY=302e020100300506032b657004220420ed5a93073.....
    HEDERA_NETWORK=testnet
    ```
  </Accordion>

  <Accordion title="JavaScript">
    ```javascript theme={null}
    import {
        Client, PrivateKey, AccountId, AccountCreateTransaction, Hbar, NftId, 
        TokenCreateTransaction, TokenType, TokenMintTransaction, AccountBalanceQuery,
        TokenAirdropTransaction,
        TokenClaimAirdropTransaction,
        TokenCancelAirdropTransaction,
        TokenRejectTransaction,
    } from "@hashgraph/sdk";

    import "dotenv/config";

    async function main() {
    if (
    process.env.OPERATOR_ID == null ||
    process.env.OPERATOR_KEY == null ||
    process.env.HEDERA_NETWORK == null
    ) {
    throw new Error(
    "Environment variables OPERATOR_ID, HEDERA_NETWORK, and OPERATOR_KEY are required.",
    );
    }

        const client = Client.forName(process.env.HEDERA_NETWORK).setOperator(
            AccountId.fromString(process.env.OPERATOR_ID),
            PrivateKey.fromStringDer(process.env.OPERATOR_KEY),
        );

        /**
         * Step 1: Create 4 accounts
         */
        const alicePrivateKey = PrivateKey.generateECDSA();
        const alicePublicKey = alicePrivateKey.publicKey;
        const { accountId: aliceId } = await (
            await new AccountCreateTransaction()
                .setKey(alicePublicKey)
                //Do NOT set an alias if you need to update/rotate keys in the future
                .setAlias(alicePublicKey.toEvmAddress())
                .setInitialBalance(new Hbar(10))
                .setMaxAutomaticTokenAssociations(-1) // unlimited associations
                .execute(client)
        ).getReceipt(client);

        const bobPrivateKey = PrivateKey.generateECDSA();
        const bobPublicKey = bobPrivateKey.publicKey;
        const { accountId: bobId } = await (
            await new AccountCreateTransaction()
                .setKey(bobPublicKey)
                //Do NOT set an alias if you need to update/rotate keys in the future
                .setAlias(alicePublicKey.toEvmAddress())
                .setInitialBalance(new Hbar(10))
                .setMaxAutomaticTokenAssociations(1) // 1 association
                .execute(client)
        ).getReceipt(client);


        const charliePrivateKey = PrivateKey.generateECDSA();
        const charliePublicKey = charliePrivateKey.publicKey;
        const { accountId: charlieId } = await (
            await new AccountCreateTransaction()
                .setKey(charliePublicKey)
                //Do NOT set an alias if you need to update/rotate keys in the future
                .setAlias(charliePublicKey.toEvmAddress())
                .setInitialBalance(new Hbar(10))
                .setMaxAutomaticTokenAssociations(0) // no association slots
                .execute(client)
        ).getReceipt(client);

        // treasury account for tokens
        const treasuryKey = PrivateKey.generateECDSA();
        const treasuryPublicKey = treasuryKey.publicKey;
        const { accountId: treasuryAccount } = await (
            await new AccountCreateTransaction()
                .setKey(treasuryPublicKey)
                //Do NOT set an alias if you need to update/rotate keys in the future
                .setAlias(treasuryPublicKey.toEvmAddress())
                .setInitialBalance(new Hbar(10))
                .setMaxAutomaticTokenAssociations(-1)
                .execute(client)
        ).getReceipt(client);

        /**
         * Step 2: Create FT and NFT mint
         */
        const INITIAL_SUPPLY = 300;
        const tokenCreateTx = await new TokenCreateTransaction()
            .setTokenName("GameGold")
            .setTokenSymbol("GG")
            .setDecimals(3)
            .setInitialSupply(INITIAL_SUPPLY)
            .setTreasuryAccountId(treasuryAccount)
            .setAdminKey(client.operatorPublicKey)
            .setFreezeKey(client.operatorPublicKey)
            .setSupplyKey(client.operatorPublicKey)
            .setMetadataKey(client.operatorPublicKey)
            .setPauseKey(client.operatorPublicKey)
            .freezeWith(client)
            .sign(treasuryKey);

        const { tokenId } = await (
            await tokenCreateTx.execute(client)
        ).getReceipt(client);

        /**
         * Step 3: Airdrop fungible tokens to 3 accounts
         */
        const AIRDROP_SUPPLY_PER_ACCOUNT = INITIAL_SUPPLY / 3;
        const airdropRecord = await (
            await (
                await new TokenAirdropTransaction()
                    .addTokenTransfer(
                        tokenId,
                        treasuryAccount,
                        -AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .addTokenTransfer(
                        tokenId,
                        aliceId,
                        AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .addTokenTransfer(
                        tokenId,
                        treasuryAccount,
                        -AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .addTokenTransfer(
                        tokenId,
                        bobId,
                        AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .addTokenTransfer(
                        tokenId,
                        treasuryAccount,
                        -AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .addTokenTransfer(
                        tokenId,
                        charlieId,
                        AIRDROP_SUPPLY_PER_ACCOUNT,
                    )
                    .freezeWith(client)
                    .sign(treasuryKey)
            ).execute(client)
        ).getRecord(client);

        // Get the transaction record and see the pending airdrops
        const { newPendingAirdrops } = airdropRecord;
        console.log("Pending airdrop", newPendingAirdrops[0]);

        // Query to verify Alice and Bob have received the airdrops and Charlie has not
        let aliceBalance = await new AccountBalanceQuery()
            .setAccountId(aliceId)
            .execute(client);

        let bobBalance = await new AccountBalanceQuery()
            .setAccountId(bobId)
            .execute(client);

        let charlieBalance = await new AccountBalanceQuery()
            .setAccountId(charlieId)
            .execute(client);

        console.log(
            "Alice balance after airdrop: ",
            aliceBalance.tokens.get(tokenId).toInt(),
        );
        console.log(
            "Bob balance after airdrop: ",
            bobBalance.tokens.get(tokenId).toInt(),
        );
        console.log(
            "Charlie balance after airdrop: ",
            charlieBalance.tokens.get(tokenId),
        );

        /**
         * Step 4: Claim the airdrop for Charlie's account
         */
        console.log("Pending airdrop ID: ", newPendingAirdrops[0].airdropId);
        const tokenClaimTx = await new TokenClaimAirdropTransaction()
            .addPendingAirdropId(newPendingAirdrops[0].airdropId)
            .freezeWith(client)
            .sign(charliePrivateKey);
        const tokenClaimTxResponse = await tokenClaimTx.execute(client);
        const tokenClaimTxReceipt = await tokenClaimTxResponse.getReceipt(client);

        console.log(
            `Status of token claim airdrop transaction: ${tokenClaimTxReceipt.status.toString()}`,
        );

        const charlieBalanceAfterClaim = await new AccountBalanceQuery()
            .setAccountId(charlieId)
            .execute(client);

        console.log(
            "Charlie balance after airdrop claim",
            charlieBalanceAfterClaim.tokens.get(tokenId).toInt(),
        );

        /**
         * Step 5: Airdrop the NFTs to Alice, Bob, and Charlie
         */
        const CID = [
            "QmNPCiNA3Dsu3K5FxDPMG5Q3fZRwVTg14EXA92uqEeSRXn",
            "QmZ4dgAgt8owvnULxnKxNe8YqpavtVCXmc1Lt2XajFpJs9",
            "QmPzY5GxevjyfMUF5vEAjtyRoigzWp47MiKAtLBduLMC1T",
            "Qmd3kGgSrAwwSrhesYcY7K54f3qD7MDo38r7Po2dChtQx5",
            "QmWgkKz3ozgqtnvbCLeh7EaR1H8u5Sshx3ZJzxkcrT3jbw",
        ];

        // Create Game NFT
        const { tokenId: nftId } = await (
            await (
                await new TokenCreateTransaction()
                    .setTokenName("Game NFT")
                    .setTokenSymbol("GNFT")
                    .setTokenType(TokenType.NonFungibleUnique)
                    .setTreasuryAccountId(treasuryAccount)
                    .setAdminKey(client.operatorPublicKey)
                    .setFreezeKey(client.operatorPublicKey)
                    .setSupplyKey(client.operatorPublicKey)
                    .setMetadataKey(client.operatorPublicKey)
                    .setPauseKey(client.operatorPublicKey)
                    .freezeWith(client)
                    .sign(treasuryKey)
            ).execute(client)
        ).getReceipt(client);

        let serialsNfts = [];
        for (let i = 0; i < CID.length; i++) {
            const { serials } = await (
                await new TokenMintTransaction()
                    .setTokenId(nftId)
                    .addMetadata(Buffer.from("-"))
                    .execute(client)
            ).getReceipt(client);

            serialsNfts.push(serials[0]);
        }

        // Airdrop NFTs
        const { newPendingAirdrops: newPendingAirdropsNfts } = await (
            await (
                await new TokenAirdropTransaction()
                    .addNftTransfer(
                        nftId,
                        serialsNfts[0],
                        treasuryAccount,
                        aliceId,
                    )
                    .addNftTransfer(
                        nftId,
                        serialsNfts[1],
                        treasuryAccount,
                        bobId,
                    )
                    .addNftTransfer(
                        nftId,
                        serialsNfts[2],
                        treasuryAccount,
                        charlieId,
                    )
                    .freezeWith(client)
                    .sign(treasuryKey)
            ).execute(client)
        ).getRecord(client);

        // Get the tx record and verify two pending airdrops (for Bob and Charlie)
        console.log("Pending airdrops length", newPendingAirdropsNfts.length);
        console.log("Pending airdrop for Bob:", newPendingAirdropsNfts[0]);
        console.log("Pending airdrop for Charlie:", newPendingAirdropsNfts[1]);

        /**
         * Step 6: Cancel the airdrop for Charlie
         * No signature is needed as the operator account is the admin of the token
         */
        await new TokenCancelAirdropTransaction()
            .addPendingAirdropId(newPendingAirdropsNfts[1].airdropId) // Charlie's airdrop
            .execute(client);

        /**
         * Step 7: Reject the fungible tokens for Charlie
         */
        await (
            await (
                await new TokenRejectTransaction()
                    .setOwnerId(charlieId)
                    .addTokenId(tokenId)
                    .freezeWith(client)
                    .sign(charliePrivateKey)
            ).execute(client)
        ).getReceipt(client);

        charlieBalance = await new AccountBalanceQuery()
            .setAccountId(charlieId)
            .execute(client);

        console.log(
            "Charlie balance after reject: ",
            charlieBalance.tokens.get(tokenId).toInt(),
        );

        client.close();

    }

    void main();

    ```
  </Accordion>

  <Accordion title="Go">
    ```go theme={null}
    package main

    import (
    	"fmt"
    	"log"
    	"os"
    	"time"

    	hedera "github.com/hiero-ledger/hiero-sdk-go/v2/sdk"
    	"github.com/joho/godotenv"
    )

    func main() {
    	err := godotenv.Load(".env")
    	if err != nil {
    		panic(fmt.Errorf("Unable to load environment variables from .env file. Error:n%v\n", err))
    	}

    	operatorId, err := hedera.AccountIDFromString(os.Getenv("OPERATOR_ID"))
    	if err != nil {
    		panic(err)
    	}

    	operatorKey, err := hedera.PrivateKeyFromString(os.Getenv("OPERATOR_KEY"))
    	if err != nil {
    		panic(err)
    	}

    	client := hedera.ClientForTestnet()
    	client.SetOperator(operatorId, operatorKey)
    	client.SetDefaultMaxTransactionFee(hedera.HbarFrom(100, hedera.HbarUnits.Hbar))
    	client.SetDefaultMaxQueryPayment(hedera.HbarFrom(50, hedera.HbarUnits.Hbar))

    	// Step 1: Create 4 accounts
    	alicePrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
    	if err != nil {
    		log.Fatalf("Error generating private key for Alice: %v", err)
    	}
    	aliceId := createAccount(client, alicePrivateKey, 10, -1) // Unlimited associations

    	bobPrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
    	if err != nil {
    		log.Fatalf("Error generating private key for Bob: %v", err)
    	}
    	bobId := createAccount(client, bobPrivateKey, 10, 1) // 1 association

    	charliePrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
    	if err != nil {
    		log.Fatalf("Error generating private key for Charlie: %v", err)
    	}
    	charlieId := createAccount(client, charliePrivateKey, 10, 0) // No associations

    	treasuryPrivateKey, err := hedera.PrivateKeyGenerateEcdsa()
    	if err != nil {
    		log.Fatalf("Error generating private key for Treasury: %v", err)
    	}
    	treasuryAccount := createAccount(client, treasuryPrivateKey, 10, -1) // Unlimited associations

    	fmt.Printf("Alice Account ID: %v\n", aliceId)
    	fmt.Printf("Bob Account ID: %v\n", bobId)
    	fmt.Printf("Charlie Account ID: %v\n", charlieId)
    	fmt.Printf("Treasury Account ID: %v\n", treasuryAccount)

    	// Step 2: Create FT and mint
    	tokenCreateTx, err := hedera.NewTokenCreateTransaction().
    		SetTokenName("GameGold").
    		SetTokenSymbol("GG").
    		SetDecimals(3).
    		SetInitialSupply(300).
    		SetTreasuryAccountID(treasuryAccount).
    		SetAdminKey(client.GetOperatorPublicKey()).
    		SetFreezeKey(client.GetOperatorPublicKey()).
    		SetSupplyKey(client.GetOperatorPublicKey()).
    		SetMetadataKey(client.GetOperatorPublicKey()).
    		FreezeWith(client)

    	if err != nil {
    		log.Fatalf("Error creating fungible token transaction: %v", err)
    	}

    	tokenCreateTxSigned := tokenCreateTx.Sign(treasuryPrivateKey)
    	tokenCreateTxReceipt, err := tokenCreateTxSigned.Execute(client)
    	if err != nil {
    		log.Fatalf("Error executing fungible token transaction: %v", err)
    	}

    	receipt, err := tokenCreateTxReceipt.GetReceipt(client)
    	if err != nil {
    		log.Fatalf("Error getting receipt for fungible token: %v", err)
    	}

    	tokenId := *receipt.TokenID
    	fmt.Printf("Created fungible token with ID: %v\n", tokenId.String())

    	// Step 3: Airdrop 100 tokens each to 3 accounts
    	airdropTx, err := hedera.NewTokenAirdropTransaction().
    		AddTokenTransfer(tokenId, treasuryAccount, -100).
    		AddTokenTransfer(tokenId, aliceId, 100).
    		AddTokenTransfer(tokenId, treasuryAccount, -100).
    		AddTokenTransfer(tokenId, bobId, 100).
    		AddTokenTransfer(tokenId, treasuryAccount, -100).
    		AddTokenTransfer(tokenId, charlieId, 100).
    		FreezeWith(client)
    	if err != nil {
    		log.Fatalf("Error creating token airdrop transaction: %v", err)
    	}

    	airdropTxSigned := airdropTx.Sign(treasuryPrivateKey)
    	airdropTxReceipt, err := airdropTxSigned.Execute(client)
    	if err != nil {
    		log.Fatalf("Error executing token airdrop transaction: %v", err)
    	}
    	airdropTxRecord, err := airdropTxReceipt.GetRecord(client)
    	if err != nil {
    		log.Fatalf("Error getting record for token airdrop transaction: %v", err)
    	}
    	fmt.Println("Pending airdrop: ", airdropTxRecord.PendingAirdropRecords[0].String())
    	fmt.Println("Airdropped fungible tokens")

    	aliceBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(aliceId).Execute(client)
    	fmt.Println("Alice's balance: ", aliceBalance.Tokens.Get(tokenId))
    	bobBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(bobId).Execute(client)
    	fmt.Println("Bob's balance: ", bobBalance.Tokens.Get(tokenId))
    	charlieBalance, _ := hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
    	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))

    	// Step 4: Claim the airdrop for Charlie's account
    	tokenClaimTx, err := hedera.NewTokenClaimAirdropTransaction().AddPendingAirdropId(airdropTxRecord.PendingAirdropRecords[0].GetPendingAirdropId()).FreezeWith(client)
    	if err != nil {
    		log.Fatalf("Error creating token claim airdrop transaction: %v", err)
    	}
    	tokenClaimTxSigned := tokenClaimTx.Sign(charliePrivateKey)

    	_, err = tokenClaimTxSigned.Execute(client)
    	if err != nil {
    		log.Fatalf("Error executing token claim airdrop transaction: %v", err)
    	}
    	fmt.Println("Claimed airdrop for Charlie's account")
    	time.Sleep(4 * time.Second)
    	charlieBalance, _ = hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
    	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))

    	// Step 5: Airdrop the NFTs to Alice, Bob, and Charlie
    	CID := [][]byte{
    		[]byte("ipfs://bafyreiao6ajgsfji6qsgbqwdtjdu5gmul7tv2v3pd6kjgcw5o65b2ogst4/metadata.json"),
    		[]byte("ipfs://bafyreic463uarchq4mlufp7pvfkfut7zeqsqmn3b2x3jjxwcjqx6b5pk7q/metadata.json"),
    		[]byte("ipfs://bafyreihhja55q6h2rijscl3gra7a3ntiroyglz45z5wlyxdzs6kjh2dinu/metadata.json"),
    		[]byte("ipfs://bafyreidb23oehkttjbff3gdi4vz7mjijcxjyxadwg32pngod4huozcwphu/metadata.json"),
    		[]byte("ipfs://bafyreie7ftl6erd5etz5gscfwfiwjmht3b52cevdrf7hjwxx5ddns7zneu/metadata.json"),
    	}
    	nftCreate, err := hedera.NewTokenCreateTransaction().
    		SetTokenName("Game NFT").
    		SetTokenSymbol("GNFT").
    		SetTokenType(hedera.TokenTypeNonFungibleUnique).
    		SetTreasuryAccountID(treasuryAccount).
    		SetSupplyKey(client.GetOperatorPublicKey()).
    		SetAdminKey(client.GetOperatorPublicKey()).
    		FreezeWith(client)

    	nftCreateTxSign := nftCreate.Sign(treasuryPrivateKey)
    	nftCreateSubmit, err := nftCreateTxSign.Execute(client)
    	if err != nil {
    		log.Fatalf("Error creating NFT: %v", err)
    	}

    	nftCreateReceipt, err := nftCreateSubmit.GetReceipt(client)
    	if err != nil {
    		log.Fatalf("Error getting receipt for NFT creation: %v", err)
    	}

    	fmt.Println("Created NFT with ID: 0.0.", nftCreateReceipt.TokenID.Token)
    	nftId := *nftCreateReceipt.TokenID
    	var serialsNfts []int64
    	mintTx, _ := hedera.NewTokenMintTransaction().
    		SetTokenID(nftId).
    		SetMetadatas(CID).
    		FreezeWith(client)
    	mintTxSign := mintTx.Sign(treasuryPrivateKey)
    	mintTxSubmit, err := mintTxSign.Execute(client)
    	if err != nil {
    		log.Fatalf("Error minting NFTs: %v", err)
    	}
    	mintTxReceipt, err := mintTxSubmit.GetReceipt(client)
    	if err != nil {
    		log.Fatalf("Error getting receipt for NFT minting: %v", err)
    	}
    	serialsNfts = mintTxReceipt.SerialNumbers
    	fmt.Printf("Minted NFT serial numbers: %v\n", serialsNfts)

    	// Airdrop NFTs
    	nftAirdropTx, err := hedera.NewTokenAirdropTransaction().
    		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 1}, treasuryAccount, aliceId).
    		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 2}, treasuryAccount, bobId).
    		AddNftTransfer(hedera.NftID{TokenID: nftId, SerialNumber: 3}, treasuryAccount, charlieId).
    		FreezeWith(client)
    	if err != nil {
    		log.Fatalf("Error creating NFT airdrop transaction: %v", err)
    	}

    	nftAirdropTxSigned := nftAirdropTx.Sign(treasuryPrivateKey)
    	nftAirdropTxSubmit, err := nftAirdropTxSigned.Execute(client)
    	if err != nil {
    		log.Fatalf("Error executing NFT airdrop transaction: %v", err)
    	}
    	nftAirdropTxRecord, err := nftAirdropTxSubmit.GetRecord(client)
    	if err != nil {
    		log.Fatalf("Error getting record for NFT airdrop transaction: %v", err)
    	}
    	fmt.Println("Pending airdrops length: ", len(nftAirdropTxRecord.PendingAirdropRecords))
    	fmt.Println("Pending airdrop for Bob: ", nftAirdropTxRecord.PendingAirdropRecords[0].String())
    	fmt.Println("Pending airdrop for Charlie: ", nftAirdropTxRecord.PendingAirdropRecords[1].String())

    	// Step 6: Cancel Airdrop for Charlie
    	hedera.NewTokenCancelAirdropTransaction().
    		AddPendingAirdropId(nftAirdropTxRecord.PendingAirdropRecords[1].GetPendingAirdropId()).
    		Execute(client)

    	// Step 7: Reject the fungible tokens for Charlie
    	tokenRejectTx, err := hedera.NewTokenRejectTransaction().
    		AddTokenID(tokenId).
    		SetOwnerID(charlieId).
    		FreezeWith(client)
    	if err != nil {
    		log.Fatalf("Error creating token reject transaction: %v", err)
    	}
    	tokenRejectTxSigned := tokenRejectTx.Sign(charliePrivateKey)
    	_, err = tokenRejectTxSigned.Execute(client)
    	if err != nil {
    		log.Fatalf("Error executing token reject transaction: %v", err)
    	}
    	fmt.Println("Rejected fungible tokens for Charlie")

    	time.Sleep(4 * time.Second)
    	charlieBalance, _ = hedera.NewAccountBalanceQuery().SetAccountID(charlieId).Execute(client)
    	fmt.Println("Charlie's balance: ", charlieBalance.Tokens.Get(tokenId))
    	client.Close()
    }

    // Helper function to generate a new Hedera account
    func createAccount(client *hedera.Client, newAccountPrivateKey hedera.PrivateKey, initialBalance float64, maxAssociations int32) hedera.AccountID {
    	newAccountPublicKey := newAccountPrivateKey.PublicKey()
    	newAccountTx, err := hedera.NewAccountCreateTransaction().
    		SetKey(newAccountPublicKey).
    		SetInitialBalance(hedera.HbarFrom(initialBalance, hedera.HbarUnits.Hbar)).
    		SetMaxAutomaticTokenAssociations(maxAssociations).
    		Execute(client)

    	if err != nil {
    		log.Fatalf("Error creating new account: %v", err)
    	}

    	receipt, err := newAccountTx.GetReceipt(client)
    	if err != nil {
    		log.Fatalf("Error getting receipt for account creation: %v", err)
    	}

    	newAccountId := *receipt.AccountID

    	return newAccountId
    }
    ```
  </Accordion>
</AccordionGroup>

***

## Additional Resources

* [**Airdrop List Verifier (NFT Studio)**](/solutions/tokenization/nft-studio/airdrop-verifier)
* [**Token Holders List Builder (NFT Studio)**](/solutions/tokenization/nft-studio/token-holders-list)