Integrating Pods with Privy

Pods allows apps to access diversified DeFi yield strategies across multiple protocols through a single API. Apps fetch strategies from Pods and execute the returned transaction bytecodes using Privy wallets. This enables deposits into lending, staking, and protocol-native yield strategies without managing complex transaction flows.

Resources

Pods Docs

Official documentation for Pods strategies and API.

Starter repo

Full working example of Pods + Privy integration.

Using Pods with Privy

For this walkthrough, the examples use the Aave USDT strategy on Polygon. The same patterns work across all Pods-supported strategies and networks—explore the complete list via the Pods API.

Setup

Below is a minimal setup for the Privy provider. To customize the provider, follow the Privy Quickstart.

import {PrivyProvider} from '@privy-io/react-auth';

export function App() {
  return (
    <PrivyProvider appId="your-privy-app-id">{/* Your application components */}</PrivyProvider>
  );
}

Configure Pods API access

Obtain your API credentials from the Pods Dashboard:

const PODS_API_URL = 'https://api.pods.finance';
const PODS_API_KEY = 'your-pods-api-key';

List available strategies

Fetch the yield strategies available for users:

const fetchStrategies = async () => {
  const response = await fetch(`${PODS_API_URL}/strategies?limit=100`, {
    method: 'GET',
    headers: {
      'x-api-key': PODS_API_KEY
    }
  });

  const {data: strategies} = await response.json();
  return strategies;
};

Each strategy includes fields like id, protocol, assetName, network, and availableActions.

Deposit into a yield strategy

1. Get the user's wallet address

import {useWallets} from '@privy-io/react-auth';

const {wallets} = useWallets();
const walletAddress = wallets[0]?.address;

2. Generate transaction bytecodes from Pods

Request the bytecodes needed to execute a deposit action:

const strategyId = 'Aave-USDT-polygon';
const action = 'lend';
const amount = '1500000'; // 1.5 USDT (6 decimals)

const response = await fetch(
  `${PODS_API_URL}/strategies/${strategyId}/bytecode?action=${action}&wallet=${walletAddress}&amount=${amount}`,
  {
    method: 'GET',
    headers: {
      'x-api-key': PODS_API_KEY
    }
  }
);

const bytecodeResponse = await response.json();

The response contains an array of transactions to execute:

type PodsBytecodeResponse = {
  feeCharged: string;
  metadata: {
    isCrossChain: boolean;
    isSameChainSwap: boolean;
    crossChainQuoteId: string;
  };
  bytecode: {
    to: string;
    value: string;
    data: string;
    chainId: string;
  }[];
};

3. Execute the transactions with Privy

Use Privy’s useSendTransaction to execute each bytecode:

import {useSendTransaction} from '@privy-io/react-auth';

const {sendTransaction} = useSendTransaction();

const executePodsStrategy = async (bytecodeResponse: PodsBytecodeResponse) => {
  for (const tx of bytecodeResponse.bytecode) {
    await sendTransaction({
      to: tx.to as `0x${string}`,
      data: tx.data as `0x${string}`,
      value: BigInt(tx.value),
      chainId: Number(tx.chainId)
    });
  }
};

Check strategy position

Fetch the user’s current position and APY for a strategy:

const fetchPosition = async (strategyId: string, walletAddress: string) => {
  const response = await fetch(`${PODS_API_URL}/strategies/${strategyId}?wallet=${walletAddress}`, {
    method: 'GET',
    headers: {
      'x-api-key': PODS_API_KEY
    }
  });

  const strategy = await response.json();
  return {
    apy: strategy.apy,
    avgApy: strategy.avgApy,
    position: strategy.position
  };
};

Withdraw from a strategy

To withdraw, use the withdraw action and execute the returned bytecodes:

import {useSendTransaction} from '@privy-io/react-auth';

const {sendTransaction} = useSendTransaction();

const withdrawFromStrategy = async (strategyId: string, walletAddress: string, amount: string) => {
  const response = await fetch(
    `${PODS_API_URL}/strategies/${strategyId}/bytecode?action=withdraw&wallet=${walletAddress}&amount=${amount}`,
    {
      method: 'GET',
      headers: {
        'x-api-key': PODS_API_KEY
      }
    }
  );

  const bytecodeResponse = await response.json();

  for (const tx of bytecodeResponse.bytecode) {
    await sendTransaction({
      to: tx.to as `0x${string}`,
      data: tx.data as `0x${string}`,
      value: BigInt(tx.value),
      chainId: Number(tx.chainId)
    });
  }
};

Pods EarnWidget

For a faster integration, Pods provides a pre-built EarnWidget component that handles strategy selection, deposits, and withdrawals with a built-in UI.

Install the Pods SDK

npm install pods-sdk @pods-sdk/components @reduxjs/toolkit react-redux redux permissionless

If your app uses Vite, install the Node polyfills plugin and add it to vite.config.ts:

npm install --save-dev vite-plugin-node-polyfills

import {defineConfig} from 'vite';
import {nodePolyfills} from 'vite-plugin-node-polyfills';

export default defineConfig({
  plugins: [nodePolyfills()]
});

import {PodsProvider, EarnWidget} from 'pods-sdk';
import {useSmartWallets} from '@privy-io/react-auth/smart-wallets';
import {usePrivy} from '@privy-io/react-auth';

const {user} = usePrivy();
const {client: smartWalletClient, getClientForChain} = useSmartWallets();

const config = {
  PODS_API_URL: 'https://api.pods.finance',
  PODS_API_KEY: 'your-pods-api-key',
  walletAddress: smartWalletClient?.account.address,
  userId: user?.id,
  globalCurrency: 'USD',
  globalCurrencyExchangeRate: 1,
  theme: {mode: 'dark', preset: 'default'}
};

Implement the bytecode processor

The widget returns bytecode for the app to execute using Privy smart wallets:

import type {BytecodeTransaction, UpdateTxStatus} from 'pods-sdk';

const processBytecode = async (
  payload: {clientTxId: string; bytecodes: BytecodeTransaction[]; simulateError?: boolean},
  ctx: {updateTxStatus: UpdateTxStatus}
) => {
  ctx.updateTxStatus({type: 'HOST_ACK', clientTxId: payload.clientTxId});

  const chainId = Number(payload.bytecodes[0].chainId);
  const chainClient = await getClientForChain({id: chainId});

  const calls = payload.bytecodes.map((b) => ({
    to: b.to as `0x${string}`,
    data: b.data as `0x${string}`,
    value: BigInt(b.value)
  }));

  ctx.updateTxStatus({type: 'SIGNATURE_PROMPTED', clientTxId: payload.clientTxId});
  const txHash = await chainClient.sendTransaction({calls});
  ctx.updateTxStatus({type: 'TX_SUBMITTED', clientTxId: payload.clientTxId, txHash});
};

<PodsProvider config={config} processBytecode={processBytecode}>
  <EarnWidget autoHeight />
</PodsProvider>

The EarnWidget requires Smart Wallets for transaction execution. Enable Smart Wallets in the Privy Dashboard under Wallet infrastructure.

Key integration tips

Handle token decimals: The amount parameter must respect the token’s decimal places. USDT and USDC use 6 decimals; most other tokens use 18.
Execute transactions in order: Pods may return multiple bytecodes for a single action. Execute them sequentially.
Verify available actions: Each strategy has an availableActions array. Check that the action exists before requesting bytecodes.
Handle errors gracefully: Wrap transaction execution in try/catch blocks to handle user rejection, insufficient funds, and network issues.

For advanced use cases, refer to the Pods Docs, or reach out in Slack.

All recipes

Integrating Pods with Privy

Resources

Pods Docs

Starter repo

Using Pods with Privy

Setup

Configure Pods API access

List available strategies

Deposit into a yield strategy

Check strategy position

Withdraw from a strategy

Pods EarnWidget

Install the Pods SDK

Configure the widget

Implement the bytecode processor

Render the widget

Key integration tips

​Resources

Pods Docs

Starter repo

​Using Pods with Privy

​Setup

​Configure Pods API access

​List available strategies

​Deposit into a yield strategy

​Check strategy position

​Withdraw from a strategy

​Pods EarnWidget

​Install the Pods SDK

​Configure the widget

​Implement the bytecode processor

​Render the widget

​Key integration tips

Resources

Using Pods with Privy

Setup

Configure Pods API access

List available strategies

Deposit into a yield strategy

Check strategy position

Withdraw from a strategy

Pods EarnWidget

Install the Pods SDK

Configure the widget

Implement the bytecode processor

Render the widget

Key integration tips