How do I create NFTs on XRPL?

Creating NFTs on the XRP Ledger is straightforward and costs approximately $0.0001 per NFT—dramatically cheaper than Ethereum's $20-$200 gas fees. Here's a comprehensive guide.

Prerequisites:

1. XRPL Wallet with activated account (10 XRP reserve + small amount for fees) 2. Metadata prepared (image, properties, description) 3. Storage for metadata (IPFS, Arweave, or HTTP server) 4. Basic understanding of XRPL transaction structure

Step-by-Step Process:

1. Prepare Your Metadata

Create a JSON file following XLS-20d standard: ```json { "name": "My Awesome NFT #1", "description": "First NFT in my collection", "image": "ipfs://QmX7K...", "attributes": [ {"trait_type": "Rarity", "value": "Legendary"}, {"trait_type": "Color", "value": "Gold"} ] } ```

2. Upload to Decentralized Storage

IPFS (Recommended): - Use Pinata.cloud, NFT.Storage, or run your own node - Upload image first, get hash: `QmImage123...` - Upload metadata JSON, get hash: `QmMetadata456...` - Final URI: `ipfs://QmMetadata456...`

Arweave (Permanent): - Use ar.io or Arweave directly - One-time payment for permanent storage - More expensive but truly permanent

3. Mint via Web Interface (Easiest Method)

xrp.cafe: 1. Connect your XRPL wallet (Xaman, Crossmark) 2. Click "Mint NFT" 3. Enter metadata URI 4. Set royalty percentage (0-50%) 5. Choose taxon (collection ID) 6. Set flags (transferable, burnable) 7. Sign transaction (~0.00012 XRP fee) 8. Receive NFTokenID confirmation

onXRP.com: - Similar process with visual collection management - Bulk minting support for large collections - Integrated marketplace listing

4. Mint Programmatically (JavaScript/TypeScript)

```javascript const xrpl = require('xrpl')

async function mintNFT() { // Connect to XRPL const client = new xrpl.Client('wss://xrplcluster.com') await client.connect() // Your wallet (use proper key management in production!) const wallet = xrpl.Wallet.fromSeed('sXXX...') // Prepare mint transaction const mintTx = { TransactionType: "NFTokenMint", Account: wallet.address, URI: xrpl.convertStringToHex("ipfs://QmMetadata456..."), Flags: 8, // Transferable (burnable = 1, onlyXRP = 2, transferable = 8) TransferFee: 1000, // 10% royalty (in basis points: 1000 = 10%) NFTokenTaxon: 0 // Collection identifier (choose any integer) } // Submit and wait for validation const response = await client.submitAndWait(mintTx, { wallet }) // Extract NFTokenID from metadata const nftID = response.result.meta.nftoken_id console.log(`NFT minted! ID: ${nftID}`) await client.disconnect() }

mintNFT() ```

5. Mint Using Python

```python from xrpl.clients import JsonRpcClient from xrpl.wallet import Wallet from xrpl.models.transactions import NFTokenMint from xrpl.transaction import submit_and_wait import binascii

# Connect client = JsonRpcClient("https://xrplcluster.com") wallet = Wallet.from_seed("sXXX...")

# Convert URI to hex uri_hex = binascii.hexlify(b"ipfs://QmMetadata456...").decode()

# Create mint transaction mint_tx = NFTokenMint( account=wallet.classic_address, uri=uri_hex, flags=8, # Transferable transfer_fee=1000, # 10% nftoken_taxon=0 )

# Submit response = submit_and_wait(mint_tx, client, wallet) print(f"NFT ID: {response.result['meta']['nftoken_id']}") ```

6. Bulk Minting Collections

For large collections (100-10,000 NFTs):

```javascript async function bulkMint(metadataArray) { const client = new xrpl.Client('wss://xrplcluster.com') await client.connect() const wallet = xrpl.Wallet.fromSeed('sXXX...') const nftIds = [] for (let i = 0; i < metadataArray.length; i++) { const mintTx = { TransactionType: "NFTokenMint", Account: wallet.address, URI: xrpl.convertStringToHex(metadataArray[i].uri), Flags: 8, TransferFee: 500, // 5% NFTokenTaxon: 1 // Same taxon for entire collection } const response = await client.submitAndWait(mintTx, { wallet }) nftIds.push(response.result.meta.nftoken_id) console.log(`Minted ${i+1}/${metadataArray.length}`) // Rate limiting (XRPL can handle more, but be courteous) await new Promise(resolve => setTimeout(resolve, 500)) } await client.disconnect() return nftIds } ```

Cost Breakdown:

Per NFT: - Mint transaction fee: ~0.00012 XRP (~$0.0001) - Reserve cost: 2 XRP per NFTokenPage (holds 32 NFTs) - Storage (IPFS): Free (with public gateways) to $0.01/month (pinning services)

For 1,000 NFT Collection: - Minting fees: 0.12 XRP (~$0.10) - Reserve: 62.5 XRP (~$50) - refundable if burned - Storage: $5-20/month for IPFS pinning - Total: ~$50-70 vs $20,000-200,000 on Ethereum

Advanced Features:

Setting Expiration: ```javascript NFTokenMint transaction does not support expiration, but offers can include LastLedgerSequence for time limits ```

Restricting Transfers: ```javascript Flags: 0 // Non-transferable (soulbound NFT) Flags: 1 // Burnable only Flags: 9 // Transferable + Burnable ```

Collection Management: ```javascript // All NFTs with same issuer + taxon = collection const collection = await client.request({ command: 'account_nfts', account: issuerAddress, ledger_index: 'validated' })

const filteredByTaxon = collection.result.account_nfts.filter( nft => nft.NFTokenTaxon === 1 ) ```

Troubleshooting:

Error: "Account not found" - Your account needs activation (10 XRP reserve) - Fund from an exchange or faucet (testnet)

Error: "Insufficient XRP" - Need small amount for transaction fees - Each NFTokenPage requires 2 XRP reserve

Error: "Invalid URI" - URI must be hex-encoded - Maximum 256 bytes (512 hex characters) - Use xrpl.convertStringToHex()

Best Practices:

1. Use IPFS or Arweave for true decentralization 2. Set appropriate royalties (5-10% standard) 3. Choose meaningful taxon for collection identity 4. Test on testnet first (wss://s.altnet.rippletest.net:51233) 5. Backup your NFTokenIDs immediately after minting 6. Verify metadata displays correctly on marketplaces

Tools and Resources:

Minting Platforms: - xrp.cafe - Simple web interface - onXRP.com - Full marketplace integration - Sologenic NFT Studio - Enterprise features

Development Libraries: - xrpl.js (JavaScript/TypeScript) - xrpl-py (Python) - xrpl4j (Java)

Metadata Tools: - Pinata.cloud - IPFS pinning - NFT.Storage - Free IPFS for NFTs - Arweave - Permanent storage

Testnet Faucets: - faucet.altnet.rippletest.net - Free test XRP

The Bottom Line:

Minting NFTs on XRPL is: - 1,000x cheaper than Ethereum - 3x faster than Polygon - Simpler than most smart contract platforms - More secure (no contract vulnerabilities)

With sub-cent costs and 4-second finality, XRPL is ideal for creators launching collections without massive upfront capital.

*Last updated: February 2026*