1---
2title: SPL Token Program
3description: Kit-compatible @solana-program/token client for mint creation, transfers, ATAs, delegation, burning, and instruction plans.
4---
5 
6# SPL Token Program
7 
8Solana's standard token program. Defines Mints (token config + supply) and Token Accounts (per-owner balances). For tokens that need extensions, use [Token-2022](token-2022.md) instead.
9 
10If using plugin clients, prefer `client.use(tokenProgram())` for a fluent API that auto-derives ATAs and defaults the payer. The low-level instructions below are for manual `pipe()` transaction building. See [overview.md](../overview.md) and [plugins.md](../plugins.md).
11 
12Program address: `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`
13 
14```ts
15import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
16```
17 
18## Account Types
19 
20### Mint (82 bytes)
21 
22```ts
23import { fetchMint, fetchMaybeMint, getMintSize } from '@solana-program/token';
24 
25const mint = await fetchMint(rpc, mintAddress);
26// mint.data.decimals, mint.data.supply, mint.data.mintAuthority, mint.data.freezeAuthority
27```
28 
29### Token Account (165 bytes)
30 
31```ts
32import { fetchToken, fetchMaybeToken, getTokenSize } from '@solana-program/token';
33 
34const token = await fetchToken(rpc, tokenAddress);
35// token.data.mint, token.data.owner, token.data.amount
36```
37 
38### Multisig
39 
40```ts
41import { fetchMultisig } from '@solana-program/token';
42 
43const multisig = await fetchMultisig(rpc, multisigAddress);
44// multisig.data.m, multisig.data.n, multisig.data.signers
45```
46 
47## PDA: Associated Token Account
48 
49One deterministic token account per owner per mint. Derived from owner + mint + token program — no on-chain lookup needed. Always prefer ATAs for user-facing flows.
50 
51```ts
52import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
53 
54const [ata] = await findAssociatedTokenPda({
55  owner: walletAddress,
56  mint: mintAddress,
57  tokenProgram: TOKEN_PROGRAM_ADDRESS,
58});
59```
60 
61## Key Instructions
62 
63### Initialize Mint
64 
65```ts
66import { getInitializeMintInstruction } from '@solana-program/token';
67 
68const ix = getInitializeMintInstruction({
69  mint: mintKeypair.address,
70  decimals: 9,
71  mintAuthority: authority.address,
72  freezeAuthority: authority.address, // optional
73});
74```
75 
76### Transfer
77 
78Prefer `getTransferCheckedInstruction` — validates mint and decimals on-chain, preventing wrong-token transfers.
79 
80```ts
81import { getTransferInstruction, getTransferCheckedInstruction } from '@solana-program/token';
82 
83// Simple transfer
84const ix = getTransferInstruction({
85  source: sourceTokenAccount,
86  destination: destTokenAccount,
87  authority: owner,
88  amount: 1_000_000n,
89});
90 
91// Checked transfer (validates decimals)
92const ix = getTransferCheckedInstruction({
93  source: sourceTokenAccount,
94  mint: mintAddress,
95  destination: destTokenAccount,
96  authority: owner,
97  amount: 1_000_000n,
98  decimals: 9,
99});
100```
101 
102### Mint To
103 
104```ts
105import { getMintToInstruction, getMintToCheckedInstruction } from '@solana-program/token';
106 
107const ix = getMintToInstruction({
108  mint: mintAddress,
109  token: destinationTokenAccount,
110  mintAuthority: authority,
111  amount: 1_000_000_000n,
112});
113```
114 
115### Approve Delegate
116 
117```ts
118import { getApproveInstruction } from '@solana-program/token';
119 
120const ix = getApproveInstruction({
121  source: tokenAccount,
122  delegate: delegateAddress,
123  owner: owner,
124  amount: 500_000n,
125});
126```
127 
128### Burn
129 
130```ts
131import { getBurnInstruction } from '@solana-program/token';
132 
133const ix = getBurnInstruction({
134  account: tokenAccount,
135  mint: mintAddress,
136  authority: owner,
137  amount: 100_000n,
138});
139```
140 
141## Instruction Plans
142 
143Handle multi-step operations (e.g., create ATA if needed). Auto-check preconditions and only include necessary instructions — use for user-facing flows.
144 
145### Create Mint
146 
147```ts
148import { getCreateMintInstructionPlan } from '@solana-program/token';
149import { executeInstructionPlan } from '@solana/instruction-plans';
150 
151const plan = getCreateMintInstructionPlan({
152  mint: mintKeypair,
153  decimals: 9,
154  mintAuthority: authority.address,
155  payer,
156  rpc,
157});
158 
159await executeInstructionPlan(rpc, plan, { payer });
160```
161 
162### Mint to ATA (Creates ATA if needed)
163 
164```ts
165import { getMintToATAInstructionPlan } from '@solana-program/token';
166 
167const plan = getMintToATAInstructionPlan({
168  mint: mintAddress,
169  mintAuthority: authority,
170  owner: recipientAddress,
171  amount: 1_000_000_000n,
172  payer,
173  rpc,
174});
175 
176await executeInstructionPlan(rpc, plan, { payer });
177```
178 
179## Complete Pattern: Create Token + Mint
180 
181```ts
182import {
183  pipe, createTransactionMessage, setTransactionMessageFeePayerSigner,
184  setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions,
185  signTransactionMessageWithSigners, sendAndConfirmTransactionFactory,
186  assertIsTransactionWithBlockhashLifetime, generateKeyPairSigner, lamports,
187} from '@solana/kit';
188import {
189  getInitializeMintInstruction, getMintToInstruction,
190  getMintSize, TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda,
191  getCreateAssociatedTokenInstruction,
192} from '@solana-program/token';
193import { getCreateAccountInstruction } from '@solana-program/system';
194 
195// 1. Generate mint keypair
196const mintKeypair = await generateKeyPairSigner();
197 
198// 2. Get rent
199const mintRent = await rpc.getMinimumBalanceForRentExemption(BigInt(getMintSize())).send();
200 
201// 3. Derive ATA
202const [ata] = await findAssociatedTokenPda({
203  owner: recipient.address,
204  mint: mintKeypair.address,
205  tokenProgram: TOKEN_PROGRAM_ADDRESS,
206});
207 
208const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
209 
210const message = pipe(
211  createTransactionMessage({ version: 0 }),
212  m => setTransactionMessageFeePayerSigner(payer, m),
213  m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
214  m => appendTransactionMessageInstructions([
215    // Create mint account
216    getCreateAccountInstruction({
217      payer,
218      newAccount: mintKeypair,
219      lamports: lamports(mintRent),
220      space: getMintSize(),
221      programAddress: TOKEN_PROGRAM_ADDRESS,
222    }),
223    // Initialize mint
224    getInitializeMintInstruction({
225      mint: mintKeypair.address,
226      decimals: 9,
227      mintAuthority: payer.address,
228    }),
229    // Create ATA
230    getCreateAssociatedTokenInstruction({
231      payer,
232      ata,
233      owner: recipient.address,
234      mint: mintKeypair.address,
235    }),
236    // Mint tokens
237    getMintToInstruction({
238      mint: mintKeypair.address,
239      token: ata,
240      mintAuthority: payer,
241      amount: 1_000_000_000n,
242    }),
243  ], m),
244);
245 
246const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
247const signed = await signTransactionMessageWithSigners(message);
248assertIsTransactionWithBlockhashLifetime(signed);
249await sendAndConfirm(signed, { commitment: 'confirmed' });
250```
251