Lamports to SOL: what is a lamport? Full conversion table

The short answer

A lamport is the smallest unit of SOL, and 1 SOL is exactly 1,000,000,000 lamports. To convert lamports to SOL, divide by one billion (move the decimal point nine places left): 5,000 lamports is 0.000005 SOL and 1,488,440 lamports is 0.00148844 SOL. Solana stores every balance, fee and rent deposit on chain as a whole number of lamports, and wallets convert to SOL only for display. For a quick conversion in either direction, use the lamports to SOL converter.

What is a lamport?

A lamport is a fractional unit of SOL worth 0.000000001 SOL, the smallest amount that can exist in a Solana account. The Solana terminology reference defines it as "a fractional native token with the value of 0.000000001 sol". There is no such thing as half a lamport in a balance.

The unit is named after Leslie Lamport, the computer scientist whose work on logical clocks and consensus (including the Paxos algorithm) underpins how distributed systems agree on the order of events. That is a fitting namesake for a network whose Proof of History is itself a way of ordering events in time.

SOL is the native token of the Solana network, and "SOL with a decimal point" is a display convention. When you see 0.5 SOL in Phantom, Solflare or Backpack, the chain holds the integer 500,000,000.

Why does Solana count in whole lamports?

Solana counts in whole lamports because integers are exact and floating-point numbers are not. Every lamport balance is an unsigned 64-bit integer (u64), so every validator computes the same result to the last unit, in any programming language. A ledger cannot tolerate the kind of rounding where 0.1 + 0.2 comes out as 0.30000000000000004, which is what most languages give you.

The largest u64 is 18,446,744,073,709,551,615, which as lamports is about 18.4 billion SOL. The total supply as of November 2026 is roughly 637 million SOL (from the getSupply RPC method), so overflow is not a practical concern for balances.

Lamports to SOL conversion table

The table below converts the lamport amounts that come up most often. The rent figures were read live from mainnet with getMinimumBalanceForRentExemption on November 4, 2026.

Lamports	SOL	What it is
1	0.000000001	The smallest possible amount
1,000	0.000001
5,000	0.000005	Base fee for one signature
10,000	0.00001	Base fee for two signatures
100,000	0.0001
550,840	0.00055084	Spare rent in an old token account (2,039,280 minus 1,488,440)
650,240	0.00065024	Rent for a 0-byte account, such as a plain wallet address, today
890,880	0.00089088	Rent for a 0-byte account before rent was lowered
1,000,000	0.001
1,066,800	0.0010668	Rent for an 82-byte SPL token mint today
1,488,440	0.00148844	Rent for a 165-byte SPL token account today
2,039,280	0.00203928	Rent for a token account opened before rent was lowered
10,000,000	0.01
100,000,000	0.1
500,000,000	0.5
1,000,000,000	1	One SOL
10,000,000,000	10
18,446,744,073,709,551,615	about 18.4 billion	Largest u64 value

Today's rent is (128 + data bytes) x 5,080 lamports. The 128 bytes are fixed per-account overhead, so a 0-byte account pays 128 x 5,080 = 650,240 lamports and a token account pays 293 x 5,080 = 1,488,440. Accounts opened at the old rate of 6,960 lamports per byte keep their original deposit, which is why wallets hold a mix of 2,039,280 and 1,488,440 lamport token accounts. For any other size, the Solana rent calculator uses the live rate, and the rent-exempt minimum by account type lists the common ones.

How do you convert lamports to SOL in your head?

Group the digits in threes from the right, then count nine digits back for the decimal point. A few anchors make it quick:

1. 1,000,000 lamports is 0.001 SOL. A million lamports is a thousandth of a SOL. 1,488,440 is "about one and a half thousandths": 0.00148844.
2. 1,000 lamports is 0.000001 SOL. A thousand lamports is a millionth of a SOL, so 5,000 lamports is five millionths: 0.000005.
3. Seven digits means thousandths, ten digits means whole SOL. A seven-digit lamport number is between 0.001 and 0.01 SOL. A ten-digit number is between 1 and 10 SOL.
4. Going the other way, append zeros. 0.25 SOL has two decimals, so add seven zeros after "25": 250,000,000 lamports.
5. Watch for "0.002 SOL" in a wallet. That is almost always 2,039,280 lamports of refundable rent, not a fee; why your Solana balance is lower than expected covers where else SOL goes.

If the zeros still blur together, paste the number into the SOL to lamports converter. It runs in your browser, needs no wallet, and rounds to the nearest lamport rather than truncating.

What is a micro-lamport?

A micro-lamport is one millionth of a lamport, so 1 lamport is 1,000,000 micro-lamports. No account can hold a micro-lamport. The unit exists only to price compute units, the measure of execution work, for priority fees: a whole lamport per compute unit would be far too coarse when a swap uses around 200,000 units.

The priority fee formula, from Agave's get_prioritization_fee in compute_budget_limits.rs, is:

priority fee (lamports) = compute-unit price (micro-lamports) x compute-unit limit / 1,000,000, rounded up

The "rounded up" matters for small prices. A worked example, with a compute-unit price of 1,234 micro-lamports and a limit of 200,000 compute units:

1. 1,234 x 200,000 = 246,800,000 micro-lamports.
2. Divide by 1,000,000: 246.8 lamports.
3. Agave rounds up to a whole lamport: 247 lamports, or 0.000000247 SOL.
4. Add the 5,000-lamport base fee for one signature: 5,247 lamports in total, or 0.000005247 SOL.

The fee is charged on the limit the transaction requests, not on the compute it actually uses. The full breakdown of base fee, priority fee and rent is in Solana transaction fees explained, and what price to set in practice is in how much priority fee to pay on Solana. The priority fee tracker shows live micro-lamport levels from the last 150 slots.

Are token base units the same as lamports?

No. Lamports are the base unit of native SOL only. Every SPL token defines its own base unit through the decimals field on its mint, and a raw token amount must be divided by 10 to the power of those decimals. I read these from mainnet with getTokenSupply:

Asset	Mint	Decimals	Raw amount for 1 whole unit
SOL (native)	none, it is lamports	9	1,000,000,000 lamports
Wrapped SOL (wSOL)	So11111111111111111111111111111111111111112	9	1,000,000,000
USDC	EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v	6	1,000,000
USDT	Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB	6	1,000,000
JUP	JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN	6	1,000,000
BONK	DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263	5	100,000
A typical NFT	varies	0	1

So a raw amount of 1,000,000 means 0.001 SOL if it is lamports, 1 USDC if it is a USDC amount and 10 BONK if it is a BONK amount. Most SPL tokens use 6 or 9 decimals, but always read the mint rather than guess.

Wrapped SOL is the one token whose base units equal lamports, because a wSOL token account holds real lamports on top of its rent. The difference between the two is covered in what wSOL is. Note also that a token account's own rent deposit is always in lamports, whatever the token: the account that holds your USDC still holds 1,488,440 or 2,039,280 lamports of SOL rent. What a Solana token account is explains why.

How do you convert lamports to SOL in code?

Keep amounts in integer lamports for as long as possible and convert only when showing them to a person. The libraries below were checked against their published packages as of November 2026.

JavaScript with @solana/web3.js 1.x

The older @solana/web3.js exports LAMPORTS_PER_SOL (1,000,000,000) and returns balances as plain numbers of lamports:

import { Connection, LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const lamports = await connection.getBalance(new PublicKey(walletAddress));
const sol = lamports / LAMPORTS_PER_SOL; // for display only

// SOL to lamports: round, never truncate
const toSend = Math.round(0.25 * LAMPORTS_PER_SOL); // 250000000

JavaScript with @solana/kit

@solana/kit (version 8.6.0 at the time of writing) represents lamports as a branded bigint, the Lamports type, and provides the lamports() helper to create one. RPC methods such as getBalance return Lamports:

import { address, createSolanaRpc, lamports } from "@solana/kit";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
const { value: balance } = await rpc.getBalance(address(walletAddress)).send();

const LAMPORTS_PER_SOL = 1_000_000_000n;
const whole = balance / LAMPORTS_PER_SOL;
const frac = (balance % LAMPORTS_PER_SOL).toString().padStart(9, "0");
console.log(`${whole}.${frac} SOL`); // exact, no floating point

const fee = lamports(5_000n);

Recent Kit versions also export sol(), solToLamports() and lamportsToSol(), which treat SOL as a 9-decimal fixed-point value: solToLamports(sol("1.5")) gives exactly 1_500_000_000n, and sol() throws by default if you pass more than nine decimals.

Rust with solana-native-token

In Rust, the constant and parser live in the solana-native-token crate (version 3.0.0), maintained by Anza and re-exported by older solana-sdk versions as native_token:

use solana_native_token::{sol_str_to_lamports, LAMPORTS_PER_SOL};

let lamports: u64 = sol_str_to_lamports("1.5").unwrap(); // 1_500_000_000
assert_eq!(LAMPORTS_PER_SOL, 1_000_000_000);

The f64-based sol_to_lamports and lamports_to_sol functions you will see in older tutorials are marked deprecated in the 2.x crate, which describes them as "approximately" converting, and they are no longer listed in 3.0.0. Use sol_str_to_lamports, which parses a decimal string and returns Option<u64>.

Solana CLI

The Solana CLI prints SOL by default, and several commands take a --lamports flag, per the Agave CLI source:

solana balance --lamports          # your balance as an integer
solana rent 165 --lamports         # rent-exempt minimum for 165 bytes

solana transfer takes its amount in SOL, so solana transfer <RECIPIENT> 0.001 sends 1,000,000 lamports.

What are the most common lamport mistakes?

Most lamport bugs come from mixing units or from floating point. These are the ones I see most often:

Mistake	What happens	Fix
Truncating a float	In JavaScript, 1.005 * 1e9 is 1004999999.9999999, so Math.floor sends 1,004,999,999 lamports, one short	Use Math.round, or parse the decimal string into a bigint
Using JavaScript numbers for large values	Numbers are exact only up to 9,007,199,254,740,991, about 9 million SOL in lamports	Use bigint, as Kit does
Dividing a token amount by a billion	A raw USDC amount of 1,000,000 shows as 0.001 instead of 1	Divide by 10^decimals from the mint
Treating RPC values as SOL	getBalance returning 1488440 is read as 1.4 million SOL	Every RPC lamport field is an integer of lamports
Assuming rent is fixed	Code that hardcodes 2,039,280 for a token account overestimates new accounts by 550,840 lamports	Call getMinimumBalanceForRentExemption
Forgetting priority fees are in micro-lamports	A price of 10,000 is read as 10,000 lamports per compute unit, a million times too much	Divide price x limit by 1,000,000

How do you convert lamports to USD?

Divide the lamports by 1,000,000,000 to get SOL, then multiply by the current price of one SOL. There is no fixed lamports-to-dollars rate, because the SOL price moves constantly and Solana's fees are fixed in lamports, not in dollars.

As an illustration only, at an example price of $150 per SOL:

Lamports	SOL	Value at an example $150 per SOL
5,000	0.000005	$0.00075
650,240	0.00065024	about $0.098
1,488,440	0.00148844	about $0.22
2,039,280	0.00203928	about $0.31
1,000,000,000	1	$150

For today's value, the SOL to USD converter uses CoinGecko's live aggregate price in USD, EUR or GBP, refreshes it every 60 seconds and shows the lamport value of whatever you type. If you are curious what the rent in your own wallet adds up to, the free read-only scan in the Solana wallet cleanup totals it in SOL before you sign anything.

Bottom line

A lamport is one billionth of a SOL and the only unit the Solana chain actually uses: balances, fees and rent are whole lamports in a 64-bit integer, and SOL is just lamports divided by 1,000,000,000. Micro-lamports, a millionth of a lamport, exist only to price priority fees, and SPL token amounts use each mint's own decimals instead. Keep values in integer lamports in code, convert only for display, and when you need a number fast, use the lamports to SOL converter, with the SOL to USD converter for the dollar value at today's price.