> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# requestAirdrop

> Requests an airdrop of lamports to a Solana account

## Parameters

<ResponseField name="pubkey" type="string" required>
  Public key of the account to receive the airdrop (base-58 encoded)
</ResponseField>

<ResponseField name="lamports" type="number" required>
  Amount of lamports to request (1 SOL = 1,000,000,000 lamports)
</ResponseField>

<ResponseField name="config" type="object" optional>
  Configuration object containing:

  <ResponseField name="commitment" type="string" optional>
    Commitment level (processed, confirmed, finalized)
  </ResponseField>
</ResponseField>

## Response

<ResponseField name="result" type="string">
  Transaction signature of the airdrop (base-58 encoded)
</ResponseField>

## Code Examples

### Basic Request

```bash theme={null}
curl https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "requestAirdrop",
  "params": [
    "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
    1000000000
  ]
}'
```

### Using web3.js

```typescript theme={null}
import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// 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

| Code   | Message                       | Solution                                          |
| ------ | ----------------------------- | ------------------------------------------------- |
| -32601 | Method not found              | Verify you're connected to a test network         |
| -32602 | Invalid params                | Check public key format and lamports amount       |
| -32003 | Transaction simulation failed | Amount may exceed limit or account may be invalid |

## Use Cases

1. **Airdrop Management**
   ```typescript theme={null}
   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**
   ```typescript theme={null}
   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**
   ```typescript theme={null}
   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;
     }
   }
   ```