How to Make a Memecoin on Solana: A Step-by-Step Guide

If you’re new to Solana, memecoins are a low-stakes way to get your hands dirty. The space is loud and chaotic, but that activity forces you to work with real building blocks, such as token mints, metadata, wallets, and RPCs. And in that work, you can see the results immediately. Building a memecoin is a simple path to understanding how Solana apps actually work in the wild.

In this tutorial, we’ll show you two practical paths to building memecoins on Solana:

1. No-code launchpads (fastest way to launch)

2. DIY minting using Solana’s SPL tooling (best for devs who want full control)

What Is a Memecoin on Solana?

On Solana, a memecoin is usually just a standard SPL fungible token with a name, symbol, image, and a launch plan. There’s nothing technically special about it—the same SPL token mechanics are used by wallets, DeFi apps, and serious consumer projects.

What makes memecoins stand out is how they’re used. Solana’s low fees and fast transactions make it easy to mint tokens, trade frequently, and experiment with launches, which is why memecoins make up a large share of token creation and trading activity on the network during active periods.

For developers, that activity is the point. Memecoins are a simple, low-stakes way to learn Solana’s core primitives (SPL tokens, metadata, wallets, and launch flows) without needing to build a full application first.

What You’re Actually Creating on Solana

A Solana token has a mint account (the token’s identifier) and users hold balances in token accounts (often the “Associated Token Account”, or ATA).

You’ll choose between:

• SPL Token program

• Token-2022 / Token Extensions if you want built-in features (e.g., metadata extensions, transfer fees, other controls).

For most memecoins: a legacy SPL token is still the safest default for maximum wallet/exchange compatibility.

Option A: Launch With a Memecoin Launchpad (No-Code)

If your goal is “get a token live and tradable ASAP”, third party launchpads do the minting and initial trading UX for you. For this option, you have several launchpads to choose from.

Pump.fun

Pump.fun's pitch is basically “launch instantly tradable tokens without seeding liquidity.” A typical flow with Pump.fun looks like:

• Pick a name, a ticker, and an image for your token

• Pay the creation fee

• The token begins trading according to the platform’s mechanism

Raydium LaunchLab

Raydium LaunchLab includes a similar create a token flow (you just need to add a name, ticker, image, and socials). They offer two distinct modes for creating and launching a new token: the simplified JustSendIt mode and the fully customizable Advanced Mode. Advanced Mode provides full control over the token's parameters and is better suited for projects requiring specific tokenomics or more complex configurations.

BONK.fun

BONK.fun is another Solana memecoin launchpad that gained a lot of attention in 2025. The platform has gained significant market share by offering community-driven incentives and transparency.

Option B: Create the Token Yourself With SPL Tooling

If you want to bypass these launchpads, you can also create a memecoin entirely yourself. To do that, you would go through the following steps.

Creating a Solana SPL Token

If you’ve ever minted an SPL token and then wondered why it shows up as “Unknown token” (or has no icon) in wallets, this is why: the SPL mint alone doesn’t carry rich metadata.

On Solana, fungible tokens are created with the SPL Token program, and the “pretty” fields (e.g. name, symbol, image, JSON URI) are commonly attached via the Metaplex Token Metadata program.

In this tutorial, you’ll mint a fungible SPL token using:

• Umi (Metaplex’s modern client framework) to build/sign/send transactions

• mpl-token-metadata helpers to create the mint + metadata in one flow

• Alchemy Solana RPC as your network connection

• Your existing Phantom wallet private key (no new keypair generation)

What You’re Actually Doing Onchain

When you run the mint script, you’re not just “creating a token”—you’re creating a small set of onchain accounts that work together so wallets and explorers know how to interpret it.

1. Mint account (SPL Token mint): This is the core onchain account that defines your token. When people talk about a “token address” on Solana, they’re usually referring to this mint account. It’s the address you’ll paste into Solana Explorer. This account stores things like:

   1. Decimals: how divisible the token is (for example, 8 decimals means 1.0 token = 100,000,000 base units).

   2. Mint authority: the key that’s allowed to mint more supply.

   3. Freeze authority (optional): a key that can freeze token accounts.

2. Metadata account (Metaplex Token Metadata PDA): The SPL Token program itself doesn’t store names, symbols, or images. That information lives in a separate metadata account created by the Metaplex Token Metadata program. This account is a Program Derived Address (PDA), deterministically derived from your mint address. That means wallets don’t need a registry or a database—they can derive the metadata address from the mint, check if it exists, and read it if it does. This is how wallets like Phantom automatically discover and display token metadata.

3. Offchain metadata (URI → JSON): The metadata account doesn’t store all the details directly. Instead, it stores a URI that points to a JSON file hosted offchain (commonly on IPFS). That JSON follows a standard schema (name, symbol, description, image), which explorers and wallets know how to fetch and render. This keeps onchain data small while still allowing rich token information.

With that context in place, the code below should make more sense: you’re creating the mint, attaching a metadata account to it, and pointing that metadata at a JSON file that wallets can read.

Now let’s build the memecoin.

Step 1: Project Setup (TypeScript + Dependencies)

First, we’ll create a new project directory and initialize a Node.js project. This gives us a clean workspace and a package.json file to manage dependencies.

• npm init -y creates a basic Node project using default settings.

• typescript lets us write typed JavaScript, which is helpful when working with Solana and Metaplex SDKs.

• ts-node allows us to run TypeScript files directly without a separate build step.

• npx tsc --init generates a tsconfig.json, which controls how TypeScript is compiled.

Next, update tsconfig.json to enable a couple of options we’ll rely on later:

• esModuleInterop allows us to use modern import syntax with common Node packages.

• resolveJsonModule lets us import .json files directly, which is useful when working with configuration and metadata.

Now we’ll install the libraries needed to interact with Solana and Metaplex:

Here’s what each package is used for:

• @solana/web3.js is the core JavaScript SDK for interacting with the Solana network.

• umi is Metaplex’s client framework for building, signing, and sending transactions.

• umi-bundle-defaults provides common defaults (like RPC handling) so we don’t have to wire everything manually.

• mpl-token-metadata contains helpers for creating and attaching token metadata.

• bs58 is used to decode Phantom’s base58-encoded private key.

• dotenv lets us safely load secrets (RPC URLs, private keys) from a .env file.

Finally, we’ll create the files we’ll use throughout the tutorial:

• mint.ts will contain the script that creates and mints the token.

• token.json will hold the offchain metadata (name, symbol, image).

• .env stores sensitive values like your RPC URL and private key.

• .gitignore ensures secrets are never committed to version control.

Let's add the following to .gitignore:

This prevents your dependencies and private keys from being checked into Git by accident.

Step 2: Add Alchemy RPC + Phantom Private Key in .env

Alchemy RPC

Alchemy provides fast & reliable Solana RPC endpoints for devnet and mainnet. Use devnet while you’re testing. To access our endpoints, you’ll need a (free!) API key. All you need to do is go to our dashboard and spin up a new Solana app in the dashboard. Make sure you turn on both the Node API and Webhooks services, and enable devnet. Fromr there, just copy/paste your API key or endpoint URL to your .env file.

Phantom Private Key Export

Phantom’s official help docs shows the exact flow to view/copy a private key: At a high level, you just need to go to your Settings, then “Manage Accounts”, then “Show Private Key”, then “Choose network”, and click continue.

Once there, you can set your .env:

A note on security: this is a “hot wallet in scripts” pattern. It’s fine for devnet experimentation, but for mainnet you should use a dedicated wallet and avoid pasting keys into random projects.

Step 3: Upload Image + Metadata to IPFS (Pinata)

Simply having a token.json file on your computer isn’t enough. Solana programs can’t read files from your local filesystem, and storing large metadata directly onchain would be expensive. Instead, the Token Metadata program stores a URI that points to a publicly accessible JSON file hosted offchain (commonly on IPFS). Wallets and explorers fetch that JSON using the URI to display your token’s name, symbol, and image.

You can use any IPFS for this. In this tutorial I have used Pinata. As to how it works, your uploaded file gets a CID (content identifier), and you retrieve it through a gateway URL. Pinata docs cover gateways and retrieval.

As for doing the work, you’ll first create token.json:

The order of operations here looks like:

• Upload your image → copy the gateway URL.

• Paste that URL into token.json.image

• Upload the updated token.json → copy the gateway URL for the JSON.

• Put that JSON URL into .env:

You can use your own image or metadata, or use the example image below.

Step 4: Fund Your Wallet With Devnet SOL

Minting and creating accounts costs SOL (even on devnet). The good news is that devnet SOL are free. To get some, you can use Solana’s official devnet faucet to get test SOL.

Step 5: Mint the Token (Umi + Token Metadata) via Alchemy RPC

Here’s the full mint.ts script with a couple of important details baked in:

• It converts Phantom’s base58 private key into a Solana Keypair (Phantom exports can be 64 bytes; some formats are 32 bytes).

• It tells Umi to use your Alchemy RPC URL. Umi’s docs: the endpoint you pass to createUmi(...) is the endpoint used for RPC calls.

• It prints the transaction signature correctly (base58), so your explorer link works.

Copy & Paste this to your mint.ts:

Let’s run the script - when the script completes successfully, the memecoin token will be minted. The output will include the mint address and a transaction link you can verify onchain.

If everything worked, boom — you just minted your memecoin token on Solana.

Step 6: Verify the Mint on a Solana Explorer

Copy the Mint address printed by the script and paste it into a Solana Explorer. Make sure you’re on devnet.

🎉 Hurray - you’ve minted your own token (your “CATY”) with a fixed initial supply of 1,000,000 and metadata wired up.

Conclusion

That’s it - you’ve now seen both paths to launching a memecoin on Solana. If you want the fastest route, launchpads like pump.fun, Raydium LaunchLab, or BONK.fun handle most of the setup for you. If you want full control, minting your own SPL token gives you a deeper understanding of how Solana tokens actually work under the hood.

Either way, you’re now equipped to spin up as many memecoins as your heart desires. If you want to keep going, check out Alchemy’s Solana docs and developer guides for deeper dives into Solana RPCs, wallets, and production-ready tooling and explore tutorials on building Solana apps, working with SPL tokens, and handling real onchain traffic.