Setting up sponsorship

Setting up native gas sponsorship allows your app to pay for all transaction fees, creating a frictionless experience across all networks.

Getting started

1. Enable gas sponsorship in the dashboard

   Go to the gas sponsorship tab in the Privy Dashboard, and enable gas sponsorship for your application.

   
2. Configure chains

   Select which chains you want to enable sponsorship for. Sponsored requests may only come from the chains that you have configured. Want support for more networks? Reach out to us!

3. Send transaction requests

   Apps must use TEE execution in order to use our native gas sponsorship feature. Learn how to migrate here!

   Ethereum (React)

   With the React SDK, use the useSendTransaction hook with sponsor: true:

   import {useSendTransaction, useWallets} from '@privy-io/react-auth';
   
   const {sendTransaction} = useSendTransaction();
   const {wallets} = useWallets();
   
   sendTransaction(
     {
       to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
       value: 100000
     },
     {
       sponsor: true // Enable gas sponsorship
     }
   );
   

   Solana (React)

   With the React SDK, use the useSignAndSendTransaction hook with sponsor: true:

   import {useSignAndSendTransaction, useWallets} from '@privy-io/react-auth/solana';
   
   const {signAndSendTransaction} = useSignAndSendTransaction();
   const {wallets} = useWallets();
   
   const selectedWallet = wallets[0];
   
   // Create your transaction (example using @solana/kit)
   const transaction = new Uint8Array([/* your encoded transaction */]);
   
   const result = await signAndSendTransaction({
     transaction: transaction,
     wallet: selectedWallet,
     options: {
       sponsor: true // Enable gas sponsorship
     }
   });
   
   console.log('Transaction sent with signature:', result.signature);
   

   Allow transactions from the client

   To sponsor transactions from your client-side application, enable this setting in your gas sponsorship dashboard configuration. When disabled, transactions can only be sponsored from your server.

   Ethereum (REST API)

   Gas sponsored transactions share the same path and interfaces as our other RPC requests. Learn more about sending transactions here. You must also include the sponsor: true parameter for transactions to be sponsored.

   $ curl --request POST https://api.privy.io/v1/wallets/<wallet_id>/rpc \
     -u "<your-privy-app-id>:<your-privy-app-secret>" \
     -H "privy-app-id: <your-privy-app-id>" \
     -H "privy-authorization-signature: <authorization-signature-for-request>" \
     -H 'Content-Type: application/json' \
     -d '{
         "method": "eth_sendTransaction",
         "caip2": "eip155:1",
         "sponsor": true
         "params": {
             "transaction": {
                 "to": "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
                 "value": "0x2386F26FC10000",
             },
         },
     }'
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Ethereum (Node SDK)

   With the Node SDK, use the wallets().ethereum().sendTransaction method with sponsor: true:

   import { PrivyClient } from '@privy-io/node';
   
   const privy = new PrivyClient({
     appId: 'your-app-id',
     appSecret: 'your-app-secret'
   });
   
   async function sendSponsoredTransaction(walletId: string) {
     try {
       // Send a sponsored transaction on Ethereum
       const response = await privy
         .wallets()
         .ethereum()
         .sendTransaction(walletId, {
           caip2: 'eip155:1', // Ethereum mainnet
           params: {
             transaction: {
               to: '0x{address}',
               value: '0x2386F26FC10000', // Amount in wei (hex format)
               data: '0x', // optional contract call data
             },
           },
           sponsor: true, // Enable gas sponsorship
         });
   
       // Response contains transaction hash and ID
       console.log('Transaction hash:', response.hash);
       console.log('Transaction ID:', response.transaction_id);
       return response;
     } catch (error) {
       console.error('Transaction failed:', error);
       throw error;
     }
   }
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Ethereum (Rust SDK)

   With the Rust SDK, use the ethereum_send_transaction method with sponsor: true:

   use privy_rs::{PrivyClient, generated::types::*};
   
   let client = PrivyClient::new(app_id, app_secret)?;
   
   // Create a sponsored ETH transfer
   let request = EthereumSendTransactionRpcInput {
       method: "eth_sendTransaction".to_string(),
       caip2: "eip155:1".to_string(), // Ethereum mainnet
       sponsor: Some(true), // Enable gas sponsorship
       params: EthereumSendTransactionRpcInputParams {
           transaction: EthereumSendTransactionRpcInputParamsTransaction {
               to: Some("0xE3070d3e4309afA3bC9a6b057685743CF42da77C".to_string()),
               value: Some("0x2386F26FC10000".to_string()), // 0.01 ETH
               gas: None, // Let Privy estimate
               gas_price: None, // Let Privy set optimal price
               data: None,
               nonce: None,
           }
       }
   };
   
   let response = client
       .wallets()
       .ethereum_send_transaction("wallet-id", request, &authorization_context)
       .await?;
   
   println!("Sponsored transaction hash: {}", response.data.transaction_hash);
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Parameters and Returns

   See the Rust SDK documentation for detailed parameter and return types, including embedded examples:

   • WalletsClient::ethereum_send_transaction
   • EthereumSendTransactionRpcInput

   For REST API details, see the API reference.

   Solana (REST API)

   Gas sponsored transactions share the same path and interfaces as our other RPC requests. Learn more about sending transactions here. You must also include the sponsor: true parameter for transactions to be sponsored.

   $ curl --request POST https://api.privy.io/v1/wallets/<wallet_id>/rpc \
     -u "<your-privy-app-id>:<your-privy-app-secret>" \
     -H "privy-app-id: <your-privy-app-id>" \
     -H "privy-authorization-signature: <authorization-signature-for-request>" \
     -H 'Content-Type: application/json' \
     -d '{
         "method": "signAndSendTransaction",
         "caip2": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
         "sponsor": true
         "params": {
             "transaction": "insert-base-64-encoded-serialized-transaction",
             "encoding": "base64"
         }
     }'
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Solana (Node SDK)

   With the Node SDK, use the wallets().solana().signAndSendTransaction method with sponsor: true:

   import { PrivyClient } from '@privy-io/node';
   
   const privy = new PrivyClient({
     appId: 'your-app-id',
     appSecret: 'your-app-secret'
   });
   // A base64 encoded serialized transaction to sign
   const transaction = "insert-base-64-encoded-serialized-transaction";
   
   async function sendSponsoredSolanaTransaction(
     walletId: string,
     serializedTransaction: string
   ) {
     try {
       // Send a sponsored transaction on Solana
       const response = await privy
         .wallets()
         .solana()
         .signAndSendTransaction(walletId, {
           caip2: 'solana:mainnet',
           transaction, // Base64-encoded or Uint8Array
           sponsor: true, // Enable gas sponsorship
         });
   
       // Response contains transaction hash and ID
       console.log('Transaction hash:', response.hash);
       console.log('Transaction ID:', response.transaction_id);
       return response;
     } catch (error) {
       console.error('Transaction failed:', error);
       throw error;
     }
   }
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Solana (Rust SDK)

   With the Rust SDK, use the solana_sign_and_send_transaction method with sponsor: true:

   use privy_rs::{PrivyClient, generated::types::*};
   
   let client = PrivyClient::new(app_id, app_secret)?;
   
   // Prepare your transaction (this example assumes you have a serialized transaction)
   let serialized_transaction = "base64-encoded-transaction-here";
   
   let request = SolanaSignAndSendTransactionRpcInput {
       method: "signAndSendTransaction".to_string(),
       caip2: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1".to_string(), // Solana mainnet
       sponsor: Some(true), // Enable gas sponsorship
       params: SolanaSignAndSendTransactionRpcInputParams {
           transaction: serialized_transaction.to_string(),
           encoding: Some("base64".to_string()),
           send_options: None,
       }
   };
   
   let response = client
       .wallets()
       .solana_sign_and_send_transaction("wallet-id", request, &authorization_context)
       .await?;
   
   println!("Sponsored transaction signature: {}", response.signature);
   

   To sponsor transactions that are initiated from a client SDK, you may relay the transaction from your server.

   Parameters and Returns

   See the Rust SDK documentation for detailed parameter and return types, including embedded examples:

   • WalletsClient::solana_sign_and_send_transaction
   • SolanaSignAndSendTransactionRpcInput

   For REST API details, see the API reference.

Certain flows that require on-chain ECDSA signature verification such as Permit2 are not supported by EIP-7702 upgraded wallets. We recommend using an approval based flow where possible.

Next steps

Transaction management

Learn how gas-sponsored transactions work and how to track transaction status with webhooks

Security best practices

Protect your application from gas sponsorship abuse with rate limiting and threat mitigation strategies

Transactions return immediately

Gas-sponsored transactions return immediately after broadcast without waiting for confirmation. Learn how to track transaction status with webhooks in the transaction management guide.

Secure your implementation before production

Gas sponsorship requires protection against abuse to prevent drainage of your balance. Review the security best practices before deploying to production.