​
Parameters

​
pubkey
string
required

Public key of the account to receive the airdrop (base-58 encoded)

​
lamports
number
required

Amount of lamports to request (1 SOL = 1,000,000,000 lamports)

​
config
object

Configuration object containing:

​
commitment
string

Commitment level (processed, confirmed, finalized)

​
Response

​
result
string

Transaction signature of the airdrop (base-58 encoded)

​
Code Examples

​
Basic Request

curl https://rpc.orbitflare.com -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "requestAirdrop",
  "params": [
    "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
    1000000000
  ]
}'

​
Using web3.js

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

const connection = new Connection('https://rpc.orbitflare.com');

// Request airdrop
const signature = await connection.requestAirdrop(
  new PublicKey('83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri'),
  1000000000 // 1 SOL
);
console.log('Airdrop signature:', signature);

// Request airdrop with confirmation
async function requestAirdropWithConfirmation(
  pubkey: string,
  lamports: number,
  config: { commitment?: string }
) {
  const signature = await connection.requestAirdrop(
    new PublicKey(pubkey),
    lamports,
    config
  );
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(signature);
  
  return {
    signature,
    confirmation: {
      status: confirmation.value.err ? 'failed' : 'success',
      slot: confirmation.context.slot
    },
    request: {
      pubkey,
      lamports,
      formatted: lamports / 1e9 + ' SOL'
    },
    metadata: {
      timestamp: Date.now(),
      commitment: config.commitment
    }
  };
}

​
Notes

  1. Requests an airdrop of SOL to a Solana account
  2. Only available on test networks (devnet, testnet)
  3. The response is the transaction signature
  4. The transaction must be confirmed before funds are available
  5. The amount is limited based on network configuration

​
Best Practices

  1. Use appropriate commitment level based on your needs
  2. Wait for transaction confirmation before proceeding
  3. Handle rate limits and network errors
  4. Consider using faucet services for larger amounts
  5. Monitor transaction status for failures

​
Common Errors

CodeMessageSolution
-32601Method not foundVerify you’re connected to a test network
-32602Invalid paramsCheck public key format and lamports amount
-32003Transaction simulation failedAmount may exceed limit or account may be invalid

​
Use Cases

  1. Airdrop Management

    interface AirdropRequest {
  request: {
    pubkey: string;
    lamports: number;
    formatted: string;
  };
  transaction: {
    signature: string;
    status: 'pending' | 'success' | 'failed';
    confirmations: number;
  };
  metadata: {
    timestamp: number;
    network: string;
    commitment?: string;
  };
}

class AirdropManager {
  private readonly maxRetries = 3;
  private readonly confirmationTimeout = 30000; // 30 seconds
  
  async requestAirdrop(
    pubkey: string,
    lamports: number,
    config: { commitment?: string }
  ): Promise<AirdropRequest> {
    let retries = 0;
    let signature: string;
    
    while (retries < this.maxRetries) {
      try {
        signature = await connection.requestAirdrop(
          new PublicKey(pubkey),
          lamports,
          config
        );
        
        // Wait for confirmation
        const confirmation = await connection.confirmTransaction(signature, config.commitment);
        
        if (!confirmation.value.err) {
          return {
            request: {
              pubkey,
              lamports,
              formatted: lamports / 1e9 + ' SOL'
            },
            transaction: {
              signature,
              status: 'success',
              confirmations: 1
            },
            metadata: {
              timestamp: Date.now(),
              network: connection.rpcEndpoint,
              commitment: config.commitment
            }
          };
        }
      } catch (error) {
        retries++;
        if (retries === this.maxRetries) {
          throw error;
        }
        await new Promise(resolve => setTimeout(resolve, 1000));
      }
    }
  }
}

  2. Airdrop Monitoring

    interface AirdropStatus {
  request: {
    pubkey: string;
    lamports: number;
  };
  status: {
    signature: string;
    confirmations: number;
    slot: number;
  };
  history: Array<{
    timestamp: number;
    status: string;
    confirmations: number;
  }>;
}

class AirdropMonitor {
  private requests: Map<string, AirdropStatus> = new Map();
  
  async monitorAirdrop(
    signature: string,
    request: {
      pubkey: string;
      lamports: number;
    }
  ): Promise<AirdropStatus> {
    let status = this.requests.get(signature);
    const now = Date.now();
    
    const confirmation = await connection.getSignatureStatus(signature);
    
    if (!status) {
      status = {
        request,
        status: {
          signature,
          confirmations: confirmation?.confirmations || 0,
          slot: confirmation?.slot || 0
        },
        history: [{
          timestamp: now,
          status: confirmation ? 'confirmed' : 'pending',
          confirmations: confirmation?.confirmations || 0
        }]
      };
    } else {
      status.status.confirmations = confirmation?.confirmations || 0;
      status.status.slot = confirmation?.slot || 0;
      status.history.push({
        timestamp: now,
        status: confirmation ? 'confirmed' : 'pending',
        confirmations: confirmation?.confirmations || 0
      });
    }
    
    this.requests.set(signature, status);
    return status;
  }
}

  3. Airdrop Planning

    interface AirdropPlan {
  request: {
    pubkey: string;
    lamports: number;
    formatted: string;
  };
  recommendations: Array<{
    type: 'proceed' | 'split' | 'abort';
    reason: string;
  }>;
  metadata: {
    timestamp: number;
  };
}

class AirdropPlanner {
  private readonly maxAirdrop = 2000000000; // 2 SOL
  private readonly minAirdrop = 100000; // 0.0001 SOL
  
  async planAirdrop(
    pubkey: string,
    lamports: number
  ): Promise<AirdropPlan> {
    const recommendations: Array<{
      type: 'proceed' | 'split' | 'abort';
      reason: string;
    }> = [];
    
    if (lamports > this.maxAirdrop) {
      recommendations.push({
        type: 'split',
        reason: `Amount ${lamports} exceeds maximum airdrop of ${this.maxAirdrop}`
      });
    } else if (lamports < this.minAirdrop) {
      recommendations.push({
        type: 'abort',
        reason: `Amount ${lamports} is below minimum airdrop of ${this.minAirdrop}`
      });
    } else {
      recommendations.push({
        type: 'proceed',
        reason: 'Amount is within valid range'
      });
    }
    
    return {
      request: {
        pubkey,
        lamports,
        formatted: lamports / 1e9 + ' SOL'
      },
      recommendations,
      metadata: {
        timestamp: Date.now()
      }
    };
  }
  
  async splitAirdrop(
    pubkey: string,
    totalLamports: number
  ): Promise<Array<{
    lamports: number;
    delay: number;
  }>> {
    const chunks: Array<{
      lamports: number;
      delay: number;
    }> = [];
    
    let remaining = totalLamports;
    let delay = 0;
    
    while (remaining > 0) {
      const chunk = Math.min(remaining, this.maxAirdrop);
      chunks.push({
        lamports: chunk,
        delay
      });
      
      remaining -= chunk;
      delay += 2000; // 2 seconds between requests
    }
    
    return chunks;
  }
}