---
title: "Como criar uma memecoin na Solana: um guia passo a passo"
description: "Aprenda como criar uma memecoin na Solana usando uma launchpad ou DIY."
---

# Como criar uma memecoin na Solana: um guia passo a passo

<ImageBlock
  src="https://media.alchemy.com/1766155069-memecoins-on-solana.png"
  alt="Ilustração de memecoin com tema de gato para um guia de memecoin na Solana"
  width={3840}
  height={1800}
  priority
/>

Se você é novo em Solana, memecoins são uma forma de baixo risco de colocar a mão na massa. O espaço é barulhento e caótico, mas essa atividade te obriga a trabalhar com blocos de construção reais, como token mints, metadata, wallets e RPCs. E nesse trabalho, você vê os resultados imediatamente. Construir um memecoin é um caminho simples para entender como as apps de Solana funcionam de fato na prática.

Neste tutorial, mostraremos dois caminhos práticos para construir memecoins em Solana:

1. **[Launchpads](https://www.alchemy.com/dapps/best/crypto-launchpads) sem código** \(forma mais rápida de lançar\)
1. **Minting DIY** usando o tooling SPL da Solana \(melhor para devs que querem controle total\)

## O que é um memecoin em Solana?

Em Solana, um memecoin geralmente é apenas um token fungível SPL padrão com um nome, símbolo, imagem e um plano de lançamento. Não há nada tecnicamente especial nele — a mesma mecânica de token SPL é usada por wallets, apps de DeFi e projetos de consumo sérios.

O que faz os memecoins se destacarem é _como_ eles são usados. As taxas baixas e transações rápidas da Solana facilitam mintar tokens, negociar com frequência e experimentar lançamentos, motivo pelo qual os memecoins representam uma grande parte da criação de tokens e da atividade de negociação na rede durante períodos ativos.

Para desenvolvedores, essa atividade é o ponto principal. Memecoins são uma forma simples e de baixo risco de aprender os primitivos principais da Solana \(tokens SPL, metadata, wallets e fluxos de lançamento\) sem precisar construir uma aplicação completa primeiro.

## O que você está realmente criando em Solana

Um token Solana tem uma mint account \(o identificador do token\) e os usuários mantêm saldos em token accounts \(geralmente a “Associated Token Account”, ou ATA\).

Você vai escolher entre:

- [SPL Token program](https://solana.com/docs/tokens/basics)
- [Token-2022](https://www.solana-program.com/docs/token-2022) / Token Extensions, se quiser recursos integrados \(por exemplo, extensões de metadata, taxas de transferência, outros controles\).

Para a maioria dos memecoins: um token SPL legado ainda é o padrão mais seguro para máxima compatibilidade com wallets/exchanges.

## Opção a: lançar com um launchpad de memecoin \(sem código\)

Se seu objetivo é “colocar um token no ar e negociável o mais rápido possível”, launchpads de terceiros cuidam do minting e da experiência de negociação inicial para você. Para essa opção, você tem vários launchpads à disposição.

### Pump.fun

<ImageBlock
  src="https://media.alchemy.com/1766156582-pump.png"
  alt="Captura de tela do portal de criação de tokens do Pump"
  width={2188}
  height={1658}
/>

A proposta do [Pump.fun](https://pump.fun/) é basicamente “lance tokens instantaneamente negociáveis sem precisar prover liquidez”. Um fluxo típico com Pump.fun se parece com:

- Escolher um nome, um ticker e uma imagem para seu token
- Pagar a taxa de criação
- O token começa a ser negociado de acordo com o mecanismo da plataforma

### Raydium LaunchLab

<ImageBlock
  src="https://media.alchemy.com/1766156642-raydium.png"
  alt="Captura de tela do portal de tokens do Raydium"
  width={2188}
  height={1540}
/>

O [Raydium LaunchLab](https://raydium.io/launchpad/) inclui um fluxo de criação de token semelhante \(você só precisa adicionar um nome, ticker, imagem e redes sociais\). Eles oferecem dois modos distintos para criar e lançar um novo token: o modo simplificado JustSendIt e o Advanced Mode, totalmente customizável. O Advanced Mode oferece controle total sobre os parâmetros do token e é mais adequado para projetos que precisam de tokenomics específicos ou configurações mais complexas.

### Bonk.fun

<ImageBlock
  src="https://media.alchemy.com/1766156657-bonk.png"
  alt="Captura de tela do site do BONK"
  width={3406}
  height={1228}
/>

O [BONK.fun](https://bonk.fun/) é outro launchpad de memecoin em Solana que ganhou bastante atenção em 2025. A plataforma ganhou market share significativo ao oferecer incentivos orientados pela comunidade e transparência.

## Opção b: criar o token você mesmo com o tooling SPL

Se você quiser dispensar esses launchpads, também pode criar um memecoin inteiramente por conta própria. Para isso, você passaria pelas etapas a seguir.

### Criando um token SPL de Solana

Se você já mintou um token SPL e depois ficou se perguntando por que ele aparece como “Unknown token” \(ou não tem ícone\) nas wallets, é por isso: o mint SPL sozinho não carrega metadata detalhado.

Em Solana, tokens fungíveis são criados com o SPL Token program, e os campos “bonitos” \(por exemplo, nome, símbolo, imagem, URI de JSON\) geralmente são anexados via [Metaplex Token Metadata program.](https://developers.metaplex.com/smart-contracts/token-metadata)

Neste tutorial, você vai mintar um token SPL fungível usando:

- [Umi](https://developers.metaplex.com/dev-tools/umi/metaplex-umi-plugins) \(o framework de cliente moderno da Metaplex\) para construir/assinar/enviar transações
- helpers do mpl-token-metadata para criar o mint \+ metadata em um único fluxo
- [Alchemy Solana RPC](https://www.alchemy.com/solana) como sua conexão de rede
- Sua chave privada existente da [Phantom wallet](https://www.alchemy.com/dapps/phantom) \(sem gerar um novo keypair\)

### O que você está realmente fazendo onchain

Quando você executa o script de mint, você não está apenas “criando um token” — você está criando um pequeno conjunto de contas onchain que trabalham juntas para que wallets e exploradores saibam como interpretá-lo.

1. **Mint account** \(mint SPL Token\): esta é a conta onchain principal que define seu token. Quando as pessoas falam sobre um “endereço de token” em Solana, geralmente estão se referindo a essa mint account. É o endereço que você vai colar no [Solana Explorer](https://www.alchemy.com/dapps/list-of/block-explorers-on-solana). Essa conta armazena coisas como:

1. Decimals: quão divisível o token é \(por exemplo, 8 decimais significa que 1,0 token = 100.000.000 unidades base\).
1. Mint authority: a chave que tem permissão para mintar mais supply.
1. Freeze authority \(opcional\): uma chave que pode congelar token accounts.
1. **Metadata account** \(PDA do Metaplex Token Metadata\): o SPL Token program em si não armazena nomes, símbolos ou imagens. Essa informação fica em uma conta de metadata separada, criada pelo Metaplex Token Metadata program. Essa conta é um Program Derived Address \(PDA\), derivado deterministicamente do endereço do seu mint. Isso significa que as wallets não precisam de um registro ou de um banco de dados — elas podem derivar o endereço de metadata a partir do mint, verificar se ele existe e lê-lo se existir. É assim que wallets como a Phantom descobrem e exibem automaticamente o metadata do token.
1. **Metadata offchain** \(URI → JSON\): a conta de metadata não armazena todos os detalhes diretamente. Em vez disso, ela armazena um URI que aponta para um arquivo JSON hospedado offchain \(comumente no IPFS\). Esse JSON segue um schema padrão \(name, symbol, description, image\), que exploradores e wallets sabem como buscar e renderizar. Isso mantém os dados onchain pequenos, ao mesmo tempo em que permite informações ricas sobre o token.

Com esse contexto em mente, o código abaixo deve fazer mais sentido: você está criando o mint, anexando a ele uma conta de metadata e apontando esse metadata para um arquivo JSON que as wallets conseguem ler.

Agora vamos construir o memecoin.

## Passo 1: configuração do projeto \(TypeScript \+ dependências\)

Primeiro, vamos criar um novo diretório de projeto e inicializar um projeto Node.js. Isso nos dá um workspace limpo e um arquivo package.json para gerenciar dependências.

<CodeSnippet language="bash" code={`mkdir CATY
cd CATY

npm init -y
npm i -D typescript ts-node @types/node
npx tsc --init`} />

- `npm init -y` cria um projeto Node básico usando configurações padrão.
- typescript nos permite escrever JavaScript tipado, o que é útil ao trabalhar com os SDKs de Solana e Metaplex.
- `ts-node` permite executar arquivos TypeScript diretamente, sem uma etapa de build separada.
- `npx tsc --init` gera um tsconfig.json, que controla como o TypeScript é compilado.

Em seguida, atualize `tsconfig.json` para habilitar algumas opções nas quais vamos nos apoiar mais adiante:

<CodeSnippet
  language="json"
  code={`{
  "compilerOptions": {
    "esModuleInterop": true,
    "resolveJsonModule": true
  }
}`}
/>
- `esModuleInterop` nos permite usar a sintaxe de import moderna com pacotes
comuns do Node. - `resolveJsonModule` nos permite importar arquivos .json
diretamente, o que é útil ao trabalhar com configuração e metadata.

Agora vamos instalar as bibliotecas necessárias para interagir com Solana e Metaplex:

<CodeSnippet
  language="bash"
  code={`npm i @solana/web3.js@1 \\\\
  @metaplex-foundation/umi \\\\
  @metaplex-foundation/umi-bundle-defaults \\\\
  @metaplex-foundation/mpl-token-metadata \\\\
  bs58 dotenv`}
/>
Aqui está para que serve cada pacote:

- `@solana/web3.js` é o SDK JavaScript principal para interagir com a rede Solana.
- `umi` é o framework de cliente da Metaplex para construir, assinar e enviar transações.
- `umi-bundle-defaults` fornece padrões comuns \(como o tratamento de RPC\) para que não precisemos configurar tudo manualmente.
- `mpl-token-metadata` contém helpers para criar e anexar metadata de token.
- `bs58` é usado para decodificar a chave privada da Phantom, codificada em base58.
- `dotenv` nos permite carregar segredos \(URLs de RPC, chaves privadas\) com segurança a partir de um arquivo .env.

Por fim, vamos criar os arquivos que usaremos ao longo do tutorial:

<CodeSnippet
  language="bash"
  code={`touch mint.ts token.json .env .gitignore`}
/>
- `mint.ts` vai conter o script que cria e minta o token. - `token.json`
vai guardar o metadata offchain \(name, symbol, image\). - `.env`
armazena valores sensíveis como sua URL de RPC e chave privada. - `.gitignore`
garante que os segredos nunca sejam commitados no controle de versão.

Vamos adicionar o seguinte ao `.gitignore`:

<CodeSnippet
  language="javascript"
  code={`node_modules
.env`}
/>
Isso evita que suas dependências e chaves privadas sejam enviadas para o Git por
acidente.

## Passo 2: adicionar o RPC da Alchemy \+ a chave privada da Phantom no .env

### RPC da Alchemy

<ImageBlock
  src="https://media.alchemy.com/1766156725-alchemy_rpc.png"
  alt="Captura de tela do dashboard da Alchemy"
  width={746}
  height={914}
/>

A Alchemy fornece endpoints de RPC para Solana rápidos e confiáveis para devnet e mainnet. Use a devnet enquanto estiver testando. Para acessar nossos endpoints, você vai precisar de uma API key \(gratuita!\). Tudo o que você precisa fazer é [ir até nosso dashboard](https://dashboard.alchemy.com/) e criar uma nova app de Solana no dashboard. Certifique-se de ativar tanto o serviço de Node API quanto o de Webhooks, e habilitar a devnet. A partir daí, basta copiar e colar sua API key ou a URL do endpoint no seu arquivo .env.

### Exportar a chave privada da Phantom

Os [docs](https://help.phantom.com/hc/en-us/articles/25334064171795-How-to-view-your-recovery-phrase-or-private-key-in-Phantom) oficiais de ajuda da Phantom mostram o fluxo exato para visualizar/copiar uma chave privada: em linhas gerais, você só precisa ir em Settings, depois em “Manage Accounts”, depois em “Show Private Key”, depois em “Choose network”, e clicar em continue.

A partir daí, você pode configurar seu .env:

<CodeSnippet
  language="json"
  code={`SOLANA_RPC_URL=https://solana-devnet.g.alchemy.com/v2/YOUR_ALCHEMY_KEY
PHANTOM_PRIVATE_KEY_BASE58=PASTE_FROM_PHANTOM
TOKEN_METADATA_URI=`}
/>
Uma observação sobre segurança: este é um padrão de “hot wallet em scripts”. É
adequado para experimentação em devnet, mas para mainnet você deve usar uma wallet
dedicada e evitar colar chaves em projetos aleatórios.

## Passo 3: enviar imagem \+ metadata para o IPFS \(Pinata\)

Simplesmente ter um arquivo token.json no seu computador não é suficiente. Programas Solana não conseguem ler arquivos do seu sistema de arquivos local, e armazenar metadata grande diretamente onchain seria caro. Em vez disso, o Token Metadata program armazena um URI que aponta para um arquivo JSON acessível publicamente e hospedado offchain \(comumente no IPFS\). Wallets e exploradores buscam esse JSON usando o URI para exibir o nome, símbolo e imagem do seu token.

Você pode usar qualquer IPFS para isso. Neste tutorial usei o [Pinata](https://pinata.cloud/). Quanto a como funciona, seu arquivo enviado recebe um CID \(content identifier\), e você o recupera por meio de uma URL de gateway. Os [docs do Pinata](https://docs.pinata.cloud/quickstart) cobrem gateways e recuperação.

Quanto ao trabalho em si, primeiro você vai criar o token.json:

<CodeSnippet
  language="json"
  code={`{
  "name": "Cat with Hat",
  "symbol": "CATY",
  "description": "My Cat with Hat",
  "image": "https://YOUR_GATEWAY/ipfs/YOUR_IMAGE_CID"
}`}
/>
A ordem das operações aqui é:

- Enviar sua imagem → copiar a URL do gateway.
- Colar essa URL em token.json.image
- Enviar o token.json atualizado → copiar a URL do gateway para o JSON.
- Colocar essa URL do JSON no .env:

<CodeSnippet
  language="json"
  code={`TOKEN_METADATA_URI=https://gateway.pinata.cloud/ipfs/<YOUR_TOKEN_JSON_CID>`}
/>
Você pode usar sua própria imagem ou metadata, ou usar a imagem de exemplo abaixo.

<ImageBlock
  src="https://media.alchemy.com/1766156740-cat.webp"
  alt="Gato usando chapéu, imagem de exemplo para metadados de token de memecoin"
  width={2613}
  height={3000}
/>

## Passo 4: financiar sua wallet com SOL da Devnet

Mintar e criar contas custa SOL \(mesmo na devnet\). A boa notícia é que o SOL de devnet é gratuito. Para conseguir um pouco, você pode usar o [faucet oficial de devnet](https://faucet.solana.com/) da Solana para obter SOL de teste.

<ImageBlock
  src="https://media.alchemy.com/1766156769-solana.png"
  alt="Captura de tela de um faucet da Solana"
  width={2608}
  height={1456}
/>

## Passo 5: mintar o token \(umi \+ token metadata\) via Alchemy RPC

Aqui está o script `mint.ts` completo com alguns detalhes importantes já embutidos:

- Ele converte a chave privada base58 da Phantom em um Solana Keypair \(exports da Phantom podem ter 64 bytes; alguns formatos têm 32 bytes\).
- Ele instrui o Umi a usar a URL do seu Alchemy RPC. Nos docs do Umi: o endpoint que você passa para createUmi\(...\) é o endpoint usado para chamadas de RPC.
- Ele imprime a assinatura da transação corretamente \(base58\), para que o link do explorador funcione.

Copie e cole isto no seu `mint.ts`:

<CodeSnippet language="typescript" code={`import "dotenv/config";
import bs58 from "bs58";
import { Keypair } from "@solana/web3.js";

import {
  mplTokenMetadata,
  createAndMint,
  TokenStandard,
} from "@metaplex-foundation/mpl-token-metadata";
import {
  createSignerFromKeypair,
  generateSigner,
  percentAmount,
  signerIdentity,
} from "@metaplex-foundation/umi";
import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";

const rpcUrl = process.env.SOLANA_RPC_URL!;
const pk58 = process.env.PHANTOM_PRIVATE_KEY_BASE58!;

if (!rpcUrl) throw new Error("Missing SOLANA_RPC_URL");
if (!pk58) throw new Error("Missing PHANTOM_PRIVATE_KEY_BASE58");

// Umi uses this RPC endpoint for all subsequent RPC calls. [oai_citation:13‡developers.metaplex.com]

const umi = createUmi(rpcUrl);

// 1) Phantom base58 private key -> Solana Keypair.
// Phantom commonly exports a 64-byte secretKey; some tools export 32 bytes.
const raw = bs58.decode(pk58);
const solanaKeypair =
raw.length === 64 ? Keypair.fromSecretKey(raw)
: raw.length === 32 ? Keypair.fromSeed(raw)
: (() => { throw new Error(\`Unexpected key length: \${raw.length}\`); })();

// 2) Solana Keypair -> Umi signer + identity.
const umiKeypair = umi.eddsa.createKeypairFromSecretKey(solanaKeypair.secretKey);
const signer = createSignerFromKeypair(umi, umiKeypair);
umi.use(signerIdentity(signer));

// 3) Add Token Metadata program helpers.
// Token Metadata attaches data to fungible and non-fungible mints. [oai_citation:14‡GitHub]
umi.use(mplTokenMetadata());

// --- token config ---
const NAME = "Cat with Hat";
const SYMBOL = "CATY";
const METADATA_URI = process.env.TOKEN_METADATA_URI!;
const decimals = 8;
const supplyTokens = 1_000_000n;
const amountBaseUnits = supplyTokens \* 10n ** BigInt(decimals);

if (!METADATA_URI) throw new Error("Missing TOKEN_METADATA_URI");

(async () => {
// generateSigner creates a new keypair for the mint account.
// Your Phantom wallet pays fees and becomes the authority by default.
const mint = generateSigner(umi);

const res = await createAndMint(umi, {
mint,
authority: umi.identity,
name: NAME,
symbol: SYMBOL,
uri: METADATA_URI,
sellerFeeBasisPoints: percentAmount(0),
decimals,
amount: amountBaseUnits,
tokenOwner: umi.identity.publicKey,
tokenStandard: TokenStandard.Fungible,
}).sendAndConfirm(umi);

// Umi returns signatures as bytes; Explorer expects base58.
const sigBase58 =
typeof res.signature === "string" ? res.signature : bs58.encode(res.signature);

console.log("Mint address:", mint.publicKey.toString());
console.log("Tx:", \`https://explorer.solana.com/tx/\${sigBase58}?cluster=devnet\`);
})();`} />
Vamos executar o script — quando o script for concluído com sucesso, o token memecoin será mintado. A saída incluirá o endereço do mint e um link de transação que você pode verificar onchain.

<CodeSnippet language="bash" code={`npx ts-node mint.ts`} />
Se tudo funcionou, pronto — você acabou de mintar seu token memecoin em Solana.

<ImageBlock
  src="https://media.alchemy.com/1766156798-mint_success.png"
  alt="Captura de tela de uma resposta de mint bem-sucedida"
  width={1288}
  height={154}
/>

## Passo 6: verificar o mint em um explorador de Solana

Copie o endereço de Mint impresso pelo script e cole-o em um [Solana Explorer](https://explorer.solana.com/?cluster=devnet). Certifique-se de estar na devnet.

🎉 Parabéns — você mintou seu próprio token \(seu “CATY”\) com um supply inicial fixo de 1.000.000 e o metadata configurado.

<ImageBlock
  src="https://media.alchemy.com/1766156815-explorer.png"
  alt="Captura de tela do Solana Explorer mostrando a memecoin"
  width={2552}
  height={1364}
/>

## Conclusão

É isso — agora você viu os dois caminhos para lançar um memecoin em Solana. Se você quiser a rota mais rápida, launchpads como pump.fun, [Raydium](https://www.alchemy.com/dapps/raydium) LaunchLab ou BONK.fun cuidam da maior parte da configuração para você. Se você quiser controle total, mintar seu próprio token SPL te dá um entendimento mais profundo de como os tokens de Solana realmente funcionam por baixo dos panos.

De qualquer forma, agora você está equipado para criar quantos memecoins o seu coração desejar. Se quiser continuar aprendendo, confira os [docs de Solana da Alchemy](https://www.alchemy.com/docs/solana) e os guias para desenvolvedores para se aprofundar em RPCs de Solana, wallets e tooling pronto para produção, e explore tutoriais sobre como construir apps de Solana, trabalhar com tokens SPL e lidar com tráfego onchain real.

## Perguntas frequentes

### O que é um memecoin em Solana?

Um memecoin em Solana é um token fungível SPL padrão com um nome, símbolo, imagem e plano de lançamento. Não há nada tecnicamente especial nele, a mesma mecânica de token SPL é usada por wallets, apps de DeFi e projetos de consumo sérios.

### Quais são as duas principais formas de criar um memecoin em Solana?

Você pode usar launchpads sem código como Pump.fun, Raydium LaunchLab ou BONK.fun para o lançamento mais rápido, ou pode mintar seu próprio token usando o tooling SPL da Solana para ter controle total sobre o processo.

### Qual wallet eu preciso para criar um memecoin?

Você precisa de uma wallet compatível com Solana, como Phantom, Backpack ou [Solflare](https://www.alchemy.com/dapps/solflare), com um pouco de SOL para cobrir as taxas de transação.

### Quanto custa criar um memecoin em Solana?

Criar um token em Solana tem custo extremamente baixo, com taxas tipicamente abaixo de US$ 1 em SOL para minting básico de token e criação de conta na devnet ou mainnet.

### Qual é a diferença entre SPL Token e Token-2022?

O SPL Token é o programa de token legado e o padrão mais seguro para máxima compatibilidade com wallets e exchanges. O Token-2022 \(Token Extensions\) oferece recursos integrados como extensões de metadata e taxas de transferência, mas pode ter suporte menos universal.

### Eu preciso adicionar metadata ao meu memecoin?

Sim, o metadata \(name, symbol, image, description\) é armazenado via o Metaplex Token Metadata program e geralmente hospedado offchain no IPFS. Isso permite que wallets e exploradores exibam as informações do seu token em vez de mostrá-lo como “Unknown token”.

### O que é o Umi e por que ele é usado para mintar tokens?

Umi é o framework de cliente moderno da Metaplex usado para construir, assinar e enviar transações em Solana. Ele simplifica o processo de criar tokens e anexar metadata em um único fluxo.

### Quais contas são criadas quando eu minto um memecoin?

Você cria uma mint account \(o identificador principal do token, armazenando decimals e authorities\), uma metadata account \(um PDA que armazena name, symbol e URI\), e metadata offchain \(um arquivo JSON no IPFS contendo informações detalhadas do token\).

### Posso testar a criação de token antes de lançar na mainnet?

Sim, você pode usar a [devnet da Solana](https://www.alchemy.com/overviews/solana-devnet) para testes. Você pode obter SOL de devnet gratuitamente no faucet oficial de devnet da Solana para cobrir as taxas de transação enquanto experimenta.