How to Mint Solana NFTs Using Anchor and Metaplex

Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.

To mint a traditional Metaplex NFT on Solana, create an SPL Token mint with decimals = 0, create its Associated Token Account (ATA), write a Metaplex Token Metadata account, create a Master Edition, and mint exactly one token. An Anchor program can coordinate those operations through cross-program invocations (CPIs) into the SPL Token, Associated Token, and Metaplex Token Metadata programs.

This guide builds that Token Metadata NFT flow for local testing and Devnet. It also explains the important distinction between a legacy multi-account Token Metadata NFT and a newer single-account Metaplex Core Asset.

#	Preview	Product	Price
1		Ledger Nano S Plus - Classic Crypto Wallet	$59.00	Buy on Amazon
2		DCENT Hardware Wallet | Biometric Cold Storage, Bluetooth, Multi-Crypto	$109.00	Buy on Amazon
3		Trezor Safe 7 Crypto Hardware Wallet with Bluetooth for Android/iOS/Desktop	$249.00	Buy on Amazon
4		Cold Wallet Crypto with 2-of-3 Recovery Double Safety Design, Offline NFC Hardware Wallet for...	$45.99	Buy on Amazon
5		Ledger Nano S Plus - Classic Crypto Wallet	$59.00	Buy on Amazon

What this tutorial creates

A Solana NFT is not the image file itself. A traditional Metaplex Token Metadata NFT normally consists of:

• An SPL mint account: defines the token and records its supply, decimals, and authorities.
• An Associated Token Account: holds the token for its owner.
• A metadata PDA: stores the name, symbol, URI, seller fee, creators, update authority, and token standard.
• A Master Edition account: identifies the asset as a non-fungible edition and controls whether print editions can be created.
• Off-chain JSON: the URI in the metadata account points to JSON containing the image URL, description, and attributes.

The NFT constraints are decimals = 0, an initial supply of 1, TokenStandard::NonFungible, and a Master Edition. A successful metadata transaction alone does not necessarily complete the NFT flow.

#1 Best Overall

Ledger Nano S Plus - Classic Crypto Wallet

• All your digital assets in one place. You can manage thousands of crypto including Bitcoin, Ethereum, Solana, Tether and more.
• Defend your identity against hackers: secure your online accounts with passwordless, hardware backed, 2FA logins for all your favorite apps and websites.
• Connectivity: USB-C cable connection only. No Bluetooth.Compatible with the Ledger Wallet crypto app, both desktop (Windows, macOS, Linux) and mobile (Android only). Not compatible with iOS.
• Protect your digital assets with the industry's best security: keep your private keys offline in your private signer, battle-tested by the Donjon's white hat hackers, CC EAL 6+ certified Secure Element, constantly updated Ledger OS.
• Effortlessly build your crypto portfolio via the all in one Ledger Wallet app: buy, sell, send, receive, swap, stake and more across popular blockchains. 15,000+ coins & tokens in a single dashboard. Keep a close eye on the market. Compare service providers. Track performance. Get timely alerts. Build your portfolio with confidence.

$59.00

Buy on Amazon

The URI is stored on-chain, but the JSON and image remain external resources. A mutable HTTPS URL can change what wallets display even if the on-chain URI never changes. IPFS content addressing also does not guarantee continued pinning or gateway availability.

Token Metadata or Metaplex Core?

This tutorial uses Metaplex Token Metadata because it is the conventional SPL-token NFT architecture and has broad compatibility with existing Solana NFT tooling. It uses several accounts and CPIs.

Metaplex Core uses a newer single-account asset model. It may be preferable for a new application that does not require SPL-token compatibility and values lower account complexity. Core and Token Metadata are different APIs and asset standards; code for one cannot simply be substituted for the other.

Prerequisites and pinned versions

Install Rust through rustup, the Solana or Agave CLI, Anchor, Node.js, and Yarn or npm. Verify the tools before creating the workspace:

rustc --version
solana --version
anchor --version
node --version

The current Metaplex Anchor example documents this tested configuration:

• Anchor CLI and crates: 0.32.1
• Solana Agave CLI: 3.1.6
• Rust: 1.92.0
• Node.js: 22.15.1
• Yarn: 1.22.x
• @coral-xyz/anchor: ^0.32.1
• @metaplex-foundation/mpl-token-metadata: ^3.4.0
• @solana/spl-token: ^0.4.9

These are documentation-tested versions, not a claim that they are the newest versions on the publication date. Keep Anchor, Rust, Solana/Agave, and SPL dependencies compatible. Use the official Anchor documentation or AVM for installation instructions because installation methods change.

Create the Anchor project

anchor init solana-nft-anchor
cd solana-nft-anchor

The program can expose one instruction:

pub fn mint_nft(
    ctx: Context<MintNft>,
    name: String,
    symbol: String,
    uri: String,
) -> Result<()>

This example uses a client-generated mint keypair. That is easier to understand because a newly created mint must sign its own initialization. A PDA mint is possible, but it requires signer seeds and a program-controlled mint authority.

Rank #2

DCENT Hardware Wallet | Biometric Cold Storage, Bluetooth, Multi-Crypto

• EAL5+ CERTIFIED SECURE ELEMENT + FINGERPRINT PROTECTION — Your private keys stay encrypted offline on a certified EAL5+ chip, the same security tier used in EMV bank cards. Built by DCENT, securing crypto since 2018. Fingerprint authentication adds a second layer no PIN-only wallet can match.
• 10,000+ ASSETS NATIVE ON 100+ BLOCKCHAINS — Hold Bitcoin, Ethereum, XRP, Solana, Cardano, popular stablecoins (USDT, USDC), and NFTs in one wallet. No third-party apps, no fragmented setup — every supported asset works straight out of the box.
• TAP-TO-SIGN MOBILE EXPERIENCE — Pair your wallet with the DCENT mobile app over Bluetooth. Manage tokens, review transactions, and access in-app swap features directly from your phone — no cables, no desktop required.
• WEB3 & dAPP ACCESS VIA METAMASK — Connect to MetaMask and other browser extension wallets to manage NFTs, claim airdrops, and access dApps. A large screen and intuitive 4-button interface keep every transaction clearly visible before you sign.
• SEAMLESS FIRMWARE UPDATES & 30-DAY MONEY-BACK GUARANTEE — Apply security updates without resetting your wallet or migrating funds. Backed by Amazon's 30-day money-back guarantee — your purchase is risk-free.

$109.00

Buy on Amazon

Add Anchor SPL and Metaplex dependencies

A baseline Cargo.toml dependency section is:

[dependencies]
anchor-lang = "0.32.1"
anchor-spl = { version = "0.32.1", features = [
    "token",
    "metadata",
    "associated_token"
] }

[features]
default = []
cpi = ["no-entrypoint"]
no-entrypoint = []
no-idl = []
no-log-ix-name = []
idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]

The token feature supplies SPL Token types and CPI helpers. associated_token supports ATA creation. metadata enables the Metaplex Token Metadata CPI helpers. Match the final code to the exact crate APIs resolved by your lockfile; builder names and required accounts can change between releases.

Make Metaplex available to the local validator

A local validator does not automatically contain every external program. Add the Metaplex Token Metadata program to Anchor.toml:

[[test.validator.clone]]
address = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"

[test.validator]
bind_address = "127.0.0.1"

Cloning the program lets the local validator execute the real program at its normal program ID. The bind_address setting also addresses a local-validator issue documented for some Agave 3.x configurations.

Prepare the off-chain metadata

The URI passed to Metaplex should point to a JSON document, not directly to the image:

{
  "name": "Anchor NFT #1",
  "symbol": "ANFT",
  "description": "An NFT minted by an Anchor program.",
  "image": "https://example.com/anchor-nft-1.png",
  "attributes": [
    {
      "trait_type": "Background",
      "value": "Blue"
    }
  ]
}

Host both the JSON and image somewhere the wallet, explorer, or indexer can retrieve them. IPFS, Arweave, Irys, or a controlled HTTPS service are possible choices. Check that the JSON returns HTTP success, valid JSON, the expected content type, and a reachable image URL. For a collectible marketed as permanent, use storage and pinning arrangements appropriate to that claim; minting an NFT does not make external files permanent.

Derive the Metadata and Master Edition PDAs

The Token Metadata PDA uses these seeds:

["metadata", TOKEN_METADATA_PROGRAM_ID, mint_public_key]

The Master Edition adds the edition seed:

["metadata", TOKEN_METADATA_PROGRAM_ID, mint_public_key, "edition"]

TypeScript derivation:

const [metadataPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("metadata"),
    TOKEN_METADATA_PROGRAM_ID.toBuffer(),
    mint.publicKey.toBuffer(),
  ],
  TOKEN_METADATA_PROGRAM_ID,
);

const [masterEditionPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("metadata"),
    TOKEN_METADATA_PROGRAM_ID.toBuffer(),
    mint.publicKey.toBuffer(),
    Buffer.from("edition"),
  ],
  TOKEN_METADATA_PROGRAM_ID,
);

The PDA must be derived with the Token Metadata program ID both in the seed list and as the PDA program argument. A client and Anchor context that use different seeds will fail account validation.

Define the Anchor accounts

The context must include the payer, mint, ATA, metadata PDA, Master Edition PDA, and the programs needed by the CPIs. A representative context is:

Rank #3

Trezor Safe 7 Crypto Hardware Wallet with Bluetooth for Android/iOS/Desktop

• Dual-chip architecture for maximum protection: The next-gen, fully auditable TROPIC01 chip works alongside a certified EAL6+ Secure Element—completely NDA-free—to deliver radically transparent, industry-leading defense against physical attacks.
• Quantum-ready security: Get protection against future threats with the first-ever hardware wallet designed with quantum-ready architecture.
• See every detail with confidence: Our largest high-resolution color touchscreen makes it easy to navigate your assets, review transactions and manage your coins with clarity.
• Wireless freedom with encrypted Bluetooth control: Manage, buy, swap and stake securely using Trezor Suite on desktop or mobile. Qi2-compatible wireless charging keeps your Trezor powered up. No cables required—security meets convenience.
• Works seamlessly with Android, iOS and desktop: Connect wirelessly or via USB-C to your phone or computer. Manage your crypto anywhere with our companion Trezor Suite app.

$249.00

Buy on Amazon

#[derive(Accounts)]
pub struct MintNft<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    #[account(
        init,
        payer = payer,
        mint::decimals = 0,
        mint::authority = payer,
        mint::freeze_authority = payer,
    )]
    pub mint: Account<'info, Mint>,

    #[account(
        init,
        payer = payer,
        associated_token::mint = mint,
        associated_token::authority = payer,
    )]
    pub token_account: Account<'info, TokenAccount>,

    /// CHECK: validated by Token Metadata PDA seeds
    #[account(
        mut,
        seeds = [
            b"metadata",
            token_metadata_program.key().as_ref(),
            mint.key().as_ref()
        ],
        bump,
        seeds::program = token_metadata_program.key(),
    )]
    pub metadata_account: UncheckedAccount<'info>,

    /// CHECK: validated by Token Metadata PDA seeds
    #[account(
        mut,
        seeds = [
            b"metadata",
            token_metadata_program.key().as_ref(),
            mint.key().as_ref(),
            b"edition"
        ],
        bump,
        seeds::program = token_metadata_program.key(),
    )]
    pub master_edition: UncheckedAccount<'info>,

    pub token_program: Program<'info, Token>,
    pub associated_token_program: Program<'info, AssociatedToken>,
    pub token_metadata_program: Program<'info, Metadata>,
    pub system_program: Program<'info, System>,
    pub rent: Sysvar<'info, Rent>,
}

The exact account types and CPI signatures must match the pinned anchor-spl and Metaplex releases. The metadata and Master Edition addresses are unchecked Anchor accounts because they are owned and initialized by the external Token Metadata program; the seed constraints still validate their addresses.

Create metadata with a Metaplex CPI

Use the current builder-style API rather than copying older instruction examples. The conceptual shape is:

let create_cpi = CreateV1CpiBuilder::new(
    ctx.accounts.token_metadata_program.to_account_info(),
)
.metadata(ctx.accounts.metadata_account.to_account_info())
.mint(ctx.accounts.mint.to_account_info(), true)
.authority(ctx.accounts.payer.to_account_info())
.payer(ctx.accounts.payer.to_account_info())
.update_authority(ctx.accounts.payer.to_account_info(), true)
.master_edition(Some(ctx.accounts.master_edition.to_account_info()))
.system_program(ctx.accounts.system_program.to_account_info())
.sysvar_instructions(ctx.accounts.instructions.to_account_info())
.spl_token_program(ctx.accounts.token_program.to_account_info())
.name(name)
.symbol(symbol)
.uri(uri)
.seller_fee_basis_points(500)
.token_standard(TokenStandard::NonFungible)
.print_supply(PrintSupply::Zero);

The complete call also needs the builder’s invocation method and the exact account set required by the pinned crate. Supply the instructions sysvar in the context if that version requires it. The important values are TokenStandard::NonFungible, a Master Edition account, and PrintSupply::Zero for a one-of-one asset with no print editions.

The seller fee is metadata, not a guarantee that every marketplace will enforce or pay royalties.

Mint exactly one token

After the mint and metadata setup, mint one base unit into the owner’s ATA:

mint_to(
    CpiContext::new(
        ctx.accounts.token_program.to_account_info(),
        MintTo {
            mint: ctx.accounts.mint.to_account_info(),
            to: ctx.accounts.token_account.to_account_info(),
            authority: ctx.accounts.payer.to_account_info(),
        },
    ),
    1,
)?;

Because the mint has zero decimals, an amount of 1 means one whole indivisible token. This differs from a fungible-token example where the amount is often expressed in base units such as 1_000_000 * 10^9.

Authority policy matters

These roles are separate:

• Mint authority: can create additional tokens.
• Freeze authority: can freeze token accounts.
• Update authority: can change mutable Metaplex metadata fields.
• Payer: pays for account creation and transaction fees.
• Owner: controls the wallet holding the token.

For a one-of-one production asset, mint one token and then usually revoke the mint authority. Consider revoking the freeze authority unless the application needs it. Retain update authority only when future metadata changes are intentional, and make metadata immutable only after confirming that the URI and fields are final.

Rank #4

Sale

Cold Wallet Crypto with 2-of-3 Recovery Double Safety Design, Offline NFC Hardware Wallet for Bitcoin& 2,800+ Tokens, Trade Anywhere &Anytime, 3 pack by Safnect

• 【Military‑grade EAL6+ security&Easy to Use】Safnect crypto wallet eatures the top-tier EAL6+ security technology and a sealed secure-element chip — No Bluetooth. No Wi‑Fi. No battery. No seed phrase to manage. Your cryptocurrencies stay strongly protected from online attackers, it is immune to remote hacks and effortless for first-time users.
• 【3-Pack Backup = Double Secure】This 100% offline hardware wallet not just a 3‑pack. It's a breakthrough in key management.You can store these three cold crypto wallets in separate locations for safer, decentralized asset protection.
• 【Instant Tap Connection&Friendly for Begginer】Simply tap the crypto wallet card against your mobile device to pair with the Safnect App in seconds. Effortlessly buy, sell and transfer crypto assets safely through the app. Experience the fast convenience of a hot wallet, paired with the robust security of genuine cold storage.
• 【Multi-Chain & Multi-Account Management】 The Safnect cold crypto wallet seamlessly manages Bitcoin, Ethereum, Solana, and over 2,800 tokens across 54+ mainstream blockchains, giving you complete multi-chain and multi-account control.You can buy, sell, swap, stake, and spend cryptocurrency directly any time any way.
• 【Basically Indestructible&Easy to Carry】Only 2 mm thin with a credit-card sized design, this crypto wallet features IP66 waterproofing and bend-resistant construction. If you're a crypto holder who travels for work or just moves around a lot, you already know the struggle: Safnect crypto wallet that actually fits your life.

$45.99

Buy on Amazon

Revoking mint authority prevents additional token issuance; it does not make the JSON, image, or metadata automatically immutable.

Call the program from TypeScript

The client generates the mint, derives the PDAs and ATA, and signs with the new mint keypair:

const mint = Keypair.generate();

const [metadataPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("metadata"),
    TOKEN_METADATA_PROGRAM_ID.toBuffer(),
    mint.publicKey.toBuffer(),
  ],
  TOKEN_METADATA_PROGRAM_ID,
);

const [masterEditionPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("metadata"),
    TOKEN_METADATA_PROGRAM_ID.toBuffer(),
    mint.publicKey.toBuffer(),
    Buffer.from("edition"),
  ],
  TOKEN_METADATA_PROGRAM_ID,
);

const tokenAccount = getAssociatedTokenAddressSync(
  mint.publicKey,
  provider.wallet.publicKey,
);

const signature = await program.methods
  .mintNft("Anchor NFT #1", "ANFT", metadataUri)
  .accountsPartial({
    payer: provider.wallet.publicKey,
    mint: mint.publicKey,
    tokenAccount,
    metadataAccount: metadataPda,
    masterEdition: masterEditionPda,
    tokenProgram: TOKEN_PROGRAM_ID,
    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
    tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
    systemProgram: SystemProgram.programId,
    rent: SYSVAR_RENT_PUBKEY,
  })
  .signers([mint])
  .rpc();

console.log({ signature, mint: mint.publicKey.toBase58(), metadata: metadataPda.toBase58(), masterEdition: masterEditionPda.toBase58() });

With Anchor 0.32 and newer, accountsPartial is useful when the generated IDL does not require every account to be supplied manually. Confirm the generated IDL’s account names: Rust fields such as master_edition become client names according to Anchor’s IDL conventions. A name mismatch is a common client-side failure.

Test locally

anchor test

A successful run should start the local validator, load the cloned Token Metadata program, build and deploy the Anchor program, generate a mint, submit the transaction, and print the signature and relevant addresses. The local test proves the instructions work against the configured local programs; it does not prove mainnet readiness.

Deploy and test on Devnet

Configure the workspace and wallet in Anchor.toml:

[provider]
cluster = "devnet"
wallet = "~/.config/solana/id.json"

Then fund the wallet and deploy:

solana config set --url devnet
solana airdrop 2
anchor build
anchor deploy
anchor test --skip-local-validator

Devnet airdrops are rate-limited, and Devnet SOL has no mainnet value. Make sure the RPC, wallet, provider cluster, and explorer URL all refer to Devnet. For a production deployment, use reliable RPC infrastructure and protect authority keypairs; a paid RPC service is unnecessary for a single local test or occasional Devnet mint.

Verification checklist

Mint account

• Decimals are 0.
• Total supply is 1.
• Mint authority is revoked or intentionally retained.
• Freeze authority follows the documented policy.

Token account

• The owner is the intended wallet.
• The mint address matches the NFT mint.
• The balance is 1.

Metadata and Master Edition

• The name, symbol, URI, seller fee, update authority, and token standard are correct.
• The metadata URI returns valid JSON.
• The image URL resolves.
• The Master Edition exists and has the intended print-supply policy.

A confirmed transaction does not guarantee immediate display in a wallet, explorer, or marketplace. Indexers may need time to process the asset.

Troubleshooting

“Program account is not executable”

The local validator probably does not contain Token Metadata. Add the program clone shown above and rerun anchor test.

Best Value

Ledger Nano S Plus - Classic Crypto Wallet

• All your digital assets in one place. You can manage thousands of crypto including Bitcoin, Ethereum, Solana, Tether and more.
• Connectivity: USB-C cable connection only. No Bluetooth.Compatible with the Ledger Wallet crypto app, both desktop (Windows, macOS, Linux) and mobile (Android only). Not compatible with iOS.
• Protect your digital assets with the industry's best security: keep your private keys offline in your private signer, battle-tested by the Donjon's white hat hackers, CC EAL 6+ certified Secure Element, constantly updated Ledger OS.
• Effortlessly build your crypto portfolio via the all in one Ledger Wallet app: buy, sell, send, receive, swap, stake and more across popular blockchains. 15,000+ coins & tokens in a single dashboard. Keep a close eye on the market. Compare service providers. Track performance. Get timely alerts. Build your portfolio with confidence.
• Choose the colors that match your style: express your personality and your crypto management mood, color code your signers, one for each use (trading, staking, HOLDing...).

$59.00

Buy on Amazon

The mint is not recognized as a signer

Include the generated mint keypair in the client transaction:

.signers([mint])

The CPI must also mark the newly created mint as a signer where required.

Metadata PDA mismatch

Check the exact seed sequence: "metadata", the Token Metadata program ID, and the mint public key. Also check that the PDA program argument is the Token Metadata program, not your Anchor program.

The asset appears fungible

Inspect the accounts rather than relying only on wallet presentation. Check for zero decimals, supply of one, TokenStandard::NonFungible, and a successfully created Master Edition.

Metadata does not display

Verify that the URI is public, returns valid JSON, contains the expected fields, and references a reachable image. Successful on-chain execution does not prove that external files are available.

Master Edition creation fails

Recheck the Master Edition PDA, metadata PDA, mint address, token standard, mint authority, and whether one of the accounts already exists from an earlier test. A clean local validator can help diagnose address-reuse problems.

Rust or local-validator errors

Keep the toolchain aligned with the pinned dependencies. If using the newer Core path, Metaplex documents Rust 1.89.0 or newer for some dependency requirements. For Agave 3.x local-validator issues involving 0.0.0.0, use bind_address = "127.0.0.1".

When to use another approach

Client-generated mint versus PDA mint

A client-generated mint is simplest for a one-off or user-created NFT because the mint keypair signs initialization directly. A PDA mint provides a deterministic address and program control, but requires signer seeds, careful seed design, and a program-controlled authority.

Anchor versus direct Umi minting

If the application needs only a script or frontend mint, Metaplex’s Umi-based workflow can avoid writing a custom Rust program. Anchor is the better fit when minting must enforce payments, allowlists, quotas, game rules, or shared application state.

Classic SPL Token versus Token-2022

This tutorial uses the classic SPL Token program. Token-2022 extensions can change account and compatibility assumptions and should be selected deliberately rather than added casually to a conventional NFT flow.

Quick Recap

Bestseller No. 1

Ledger Nano S Plus - Classic Crypto Wallet

$59.00

Bestseller No. 2

DCENT Hardware Wallet | Biometric Cold Storage, Bluetooth, Multi-Crypto

$109.00

Bestseller No. 3

Trezor Safe 7 Crypto Hardware Wallet with Bluetooth for Android/iOS/Desktop

$249.00

SaleBestseller No. 4

Cold Wallet Crypto with 2-of-3 Recovery Double Safety Design, Offline NFC Hardware Wallet for Bitcoin& 2,800+ Tokens, Trade Anywhere &Anytime, 3 pack by Safnect

$45.99

Bestseller No. 5

Ledger Nano S Plus - Classic Crypto Wallet

$59.00

Production checklist

• Review mint, freeze, update, and upgrade-authority policies.
• Use stable metadata storage and validate JSON before minting.
• Simulate transactions and handle RPC errors and retries.
• Protect authority keypairs with appropriate signing controls.
• Review Devnet-to-mainnet program IDs, wallet settings, and RPC endpoints.
• Do not assume a seller fee guarantees marketplace royalty payments.
• Verify the asset independently in an explorer and supported wallet.
• Obtain a security review if the mint includes payment, allowlist, or custom business logic.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.