Solana Devnet Airdrop Not Working? How to Get Devnet SOL in 2026

Most Solana tutorials still start the same way: install the CLI, make a keypair, run solana airdrop 2. Run that against devnet today (CLI 4.2.2 here) and you get this:

$ solana airdrop 2 8AKHUj5APsyeqDo2cFPmujtJSQyLRbXdhhYSpjhXm6A7 --url devnet
Requesting airdrop of 2 SOL
Error: airdrop request failed. This can happen when the rate limit is reached.

The message blames a rate limit, so the natural move is to wait and try again later. For us it failed the same way a day later. We ran into this while funding test wallets for our own tools, and the cause turned out to be something waiting can't fix.

What the error leaves out

The CLI's airdrop command is a thin wrapper around one RPC method, requestAirdrop. Call that method yourself and the node gives a much clearer answer:

curl https://api.devnet.solana.com -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0", "id": 1,
  "method": "requestAirdrop",
  "params": ["8AKHUj5APsyeqDo2cFPmujtJSQyLRbXdhhYSpjhXm6A7", 1000000000]
}'

{
  "jsonrpc": "2.0",
  "error": {
    "code": 410,
    "message": "The RPC faucet is closed on this cluster. Request test SOL at https://faucet.solana.com"
  },
  "id": 1
}

HTTP 410, Gone: the RPC faucet is closed on this cluster. Both api.devnet.solana.com and api.testnet.solana.com gave that answer on 11 November 2026. web3.js 1.99.0 hits the same wall, because connection.requestAirdrop() sends the same call:

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

const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
await connection.requestAirdrop(new PublicKey(address), LAMPORTS_PER_SOL);
// Error: 410 Gone: {"jsonrpc":"2.0","error":{"code": 410, "message":
//   "The RPC faucet is closed on this cluster. Request test SOL at
//   https://faucet.solana.com"}, ...}

So the airdrop built into the public RPC is switched off. A setup script or a test suite that asks the public endpoint for SOL stops at that line, and it will keep stopping there until the SOL comes from somewhere else.

Three ways to get test SOL still work. Which one fits depends on whether you're clicking through an app in a browser or running code.

For a browser wallet: a web faucet

A web faucet is a page that sends devnet SOL to an address out of a wallet somebody keeps funded. We run one, the Solstack Devnet Faucet, so people can try our tools on devnet before they spend real SOL.

1. Open the faucet and switch the network to Devnet in the top bar.
2. Connect your wallet. The SOL goes to that address, and there's nothing to sign.
3. Open the X and YouTube links on the page. That unlocks the request.
4. Pick 0.25, 0.5 or 1 SOL and press Request airdrop.

The SOL shows up a few seconds later, with a Solscan link to the transfer. When we timed a request on 11 November it came back in 4.8 seconds. Each wallet address, and each IP, gets one request every 8 hours.

There's a one-minute video of the whole request at the end of this post.

The Solana Foundation runs a web faucet too, at the address the RPC error points to. Its page lists a maximum of 2 requests every 8 hours, and a higher limit if you sign in with GitHub.

For scripts and tests: a local validator

If it's code that needs the SOL, and especially if that code runs in CI, skip devnet. The CLI ships with solana-test-validator, a single-node cluster on your own machine whose faucet has no rate limit:

solana-test-validator

$ solana airdrop 100 8AKHUj5APsyeqDo2cFPmujtJSQyLRbXdhhYSpjhXm6A7 --url localhost
Signature: HVedL5eAM11D8RsDHUoT8zVpGj1CXDSG94YLLottvW4FimEbevpDqaJfYMrAY9zZyribVhnLULdk3PMaSEsH3dX
100 SOL

That's the command that fails on devnet, and here it hands over 100 SOL in one go. requestAirdrop works from web3.js as well once the connection points at http://127.0.0.1:8899.

A local validator starts out empty, though. Your own program has to be deployed to it, and anything you rely on from devnet has to be copied in when it starts:

solana-test-validator --url devnet --clone-upgradeable-program <PROGRAM_ID> --clone <ACCOUNT>

Tests that used to open with a devnet airdrop are better off here anyway. They stop depending on a faucet that somebody else can close.

For everything else: a transfer

Devnet SOL moves like any other SOL. If a teammate has some, or another wallet of yours does, one transfer covers it:

solana transfer <RECIPIENT> 0.5 --url devnet --allow-unfunded-recipient

The last flag is needed because the CLI won't send to an address that holds no SOL unless you tell it to. This is how we fund the throwaway wallets in our own test runs: one funded wallet pays the rest.

How far 1 SOL goes

A long way. Fees on devnet are the same as on mainnet: 5,000 lamports per signature, and a new token account takes a deposit of 1,488,440 lamports, about 0.0015 SOL. One SOL covers that deposit for roughly 670 token accounts.

For a sense of scale, on 10 November we ran our tools end to end on devnet. That run created a token, burned some of it, locked some, sent two multisends, opened two liquidity pools, added and removed liquidity, and launched a coin on a launchpad. All of it used about 0.55 SOL.

Devnet SOL has no value and can't be moved to mainnet, and the network can be reset, so there's little point in stockpiling it.

If you're building your own faucet

A faucet is a server that holds a funded keypair and signs a transfer when asked. The core of ours is a few lines in a Cloudflare Worker:

const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("finalized");
const tx = new Transaction({ feePayer: faucet.publicKey, blockhash, lastValidBlockHeight });
tx.add(SystemProgram.transfer({ fromPubkey: faucet.publicKey, toPubkey: recipient, lamports }));
tx.sign(faucet);
const signature = await connection.sendRawTransaction(tx.serialize());

One bug from ours might save you some time. The first version waited for the transfer with connection.confirmTransaction(). That call listens on a WebSocket subscription, and inside a Worker the subscription never answered. The SOL landed in about a second. The request then sat there until the blockhash expired, roughly 38 seconds later, and reported "Send failed" for a transfer that had gone through.

Polling over plain HTTP fixed it:

for (let i = 0; i < 16; i += 1) {
  await new Promise((r) => setTimeout(r, 750));
  const { value } = await connection.getSignatureStatuses([signature]);
  const status = value[0];
  if (status?.err) throw new Error("transfer failed");
  const level = status?.confirmationStatus;
  if (level === "confirmed" || level === "finalized") break;
}

The same request now answers in three to five seconds. On any serverless runtime, check that your confirmation step doesn't need a socket to stay open.

You'll also want a limit per address and per IP, or a single script will empty the wallet.

Which one to use

• Clicking through an app with a browser wallet: a web faucet. Ours sends up to 1 SOL per request.
• Scripts, tests and CI: solana-test-validator, then solana airdrop against localhost.
• A new wallet when you already hold devnet SOL: solana transfer.
• solana airdrop on public devnet or testnet: closed when we checked on 11 November 2026.

With SOL in the wallet, devnet is the place to rehearse anything you'd pay for on mainnet. Creating a token, sending an airdrop to a list and opening a liquidity pool all work there the way they do on mainnet.