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

# Why Pods

> Ship on-chain yield and swaps in weeks, not months

**Ship on-chain yield and swaps in weeks, not months**

Pods is a B2B infrastructure API that enables fintechs, neobanks, wallets, custodians, and exchanges to integrate DeFi yield strategies and cross-chain swaps without building or maintaining an internal blockchain engineering team.

<CardGroup cols={3}>
  <Card title="Fast Time-to-Market" icon="rocket">
    Launch DeFi products in weeks instead of months of in-house development
  </Card>

  <Card title="Normalized Data" icon="table">
    Get treated, individualized position data across all protocols via one API
  </Card>

  <Card title="Non-Custodial" icon="shield-check">
    Your users keep custody — Pods never touches private keys or funds
  </Card>
</CardGroup>

## By the Numbers

<CardGroup cols={4}>
  <Card title="13+" icon="puzzle-piece">
    DeFi protocols integrated
  </Card>

  <Card title="8" icon="link">
    Blockchain networks supported
  </Card>

  <Card title="3" icon="code">
    API calls to deploy yield
  </Card>

  <Card title="1-2 weeks" icon="calendar">
    Typical integration time
  </Card>
</CardGroup>

**Your integration:** `GET /strategies` → `GET /strategies/:id/bytecode` → user signs. Three API calls to go from zero to deployed yield.

**Direct protocol integration:** Research protocol docs → write Solidity adapters → deploy contracts → build indexer → handle chain reorgs → monitor. Months of work per protocol.

## Who Is Pods For?

Pods serves **B2B clients** building crypto financial products:

* **Fintechs & Neobanks** — Offer yield products to end users without building DeFi infrastructure
* **Wallets** — Add earn features and cross-chain swaps directly in your wallet interface
* **Custodians** — Integrate institutional-grade yield strategies for clients
* **Exchanges** — Provide seamless on-chain yield and swap products
* **Investment Platforms** — Deploy client funds into curated DeFi strategies

If you're evaluating whether to build DeFi integrations in-house or use Pods, this page is for you.

## What Pods Abstracts

Building DeFi integrations in-house requires far more than calling a few smart contract functions. Pods handles the entire complexity stack:

<AccordionGroup>
  <Accordion title="Smart Contract Interactions" icon="file-contract">
    * Protocol-specific adapters for Aave, Morpho, Lido, Compound, 1inch, Jupiter, and more
    * Transaction bytecode generation for deposits, withdrawals, and swaps
    * Multi-step transaction orchestration (approve → deposit → track)
    * Gas estimation and optimization
    * Transaction simulation and validation
  </Accordion>

  <Accordion title="Data Indexing & Chain Reorg Handling" icon="database">
    * Real-time indexing of positions across multiple chains
    * Chain reorganization detection and reconciliation
    * Historical transaction data and realized PnL tracking
    * Accounting-ready data exports
    * Multi-protocol position aggregation
  </Accordion>

  <Accordion title="Protocol Integration Maintenance" icon="wrench">
    * Protocol upgrades and versioned migrations
    * New protocol integrations (without requiring client updates)
    * Security audits and monitoring
    * Oracle validation for price feeds
    * Protocol-specific quirks and edge cases
  </Accordion>

  <Accordion title="Infrastructure & Operations" icon="server">
    * RPC node management with automatic failover
    * Job queues and background workers
    * Alerting, monitoring, and incident response
    * Rate limiting and request management
    * Webhook delivery and retry logic
  </Accordion>
</AccordionGroup>

**Without Pods:** You need a dedicated blockchain engineering team, ongoing protocol maintenance, and infrastructure ops.

**With Pods:** You call a few HTTP endpoints and focus on your product.

## The Integration Experience

Integrating DeFi yield with Pods follows a simple 3-step pattern:

### 1. Choose a Strategy

Fetch available yield strategies with current APY rates:

```javascript theme={null}
const { data: strategies } = await pods.get('/strategies')

strategies.data.forEach(s => {
  console.log(`${s.id} — ${(s.apy * 100).toFixed(2)}% APY on ${s.network}`)
})
```

### 2. Generate Bytecode

Request ready-to-execute transaction data:

```javascript theme={null}
const { data: result } = await pods.get('/strategies/aave-usdc-polygon/bytecode', {
  params: {
    action: 'lend',
    amount: '10000000', // 10 USDC
    wallet: userWalletAddress
  }
})
```

### 3. User Signs & Broadcasts

Your user signs the transaction with their wallet — **you keep custody**:

```javascript theme={null}
for (const tx of result.bytecode) {
  await wallet.sendTransaction({
    to: tx.to,
    data: tx.data,
    value: tx.value
  })
}
```

**That's it.** Funds are deployed, accruing yield, and tracked automatically.

<CardGroup cols={2}>
  <Card title="Quickstart Guide" icon="rocket" href="/getting-started/quickstart">
    Build your first integration in 5 minutes
  </Card>

  <Card title="Strategy Deposit Example" icon="code" href="/examples/javascript/strategy-deposit">
    Full end-to-end code example
  </Card>
</CardGroup>

## Non-Custodial + No Balance-Sheet Risk

Pods is **strictly infrastructure** — not a financial product.

<Info>
  **Pods never:**

  * Holds your users' private keys
  * Takes custody of funds
  * Passes funds through our smart contracts
  * Creates balance-sheet risk for your business

  **Your users:**

  * Sign transactions with their own wallets
  * Maintain full custody at all times
  * Interact directly with underlying DeFi protocols
</Info>

Transaction signing and propagation happen entirely on your side. Pods provides the data and transaction bytecode — you execute it.

## Why Not Integrate Protocols Directly?

Many teams start by building direct integrations with protocols like Aave or Morpho. Here's why that becomes complex fast:

### Direct Protocol Integration

**Requirements:**

* Solidity expertise to understand contract interfaces
* Protocol-specific adapters for each integration (Aave, Morpho, Lido, Compound, etc.)
* Indexing infrastructure to track user positions
* Chain reorg handling and reconciliation
* Monitoring, alerting, and incident response
* Ongoing maintenance for protocol upgrades
* Security audits for every new integration

**Time to market:** 3-6 months per protocol

**Team required:** 2-3 blockchain engineers + 1 DevOps

**Ongoing cost:** High (maintenance, monitoring, upgrades)

### Pods Integration

**Requirements:**

* API key
* Basic HTTP client (axios, fetch, requests)
* Wallet library for transaction signing (ethers.js, viem)

**Time to market:** 1-2 weeks for full integration

**Team required:** Any backend engineer

**Ongoing cost:** Low (pay-per-use API fees)

### Side-by-Side Comparison

|                           | Direct Integration                                                   | Pods                                                     |
| ------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------- |
| **API calls to deposit**  | 15+ (approve, encode, simulate, send, index, reconcile per protocol) | 3 (`GET /strategies` → `GET /:id/bytecode` → user signs) |
| **Protocols supported**   | 1 per integration                                                    | 13+ via one API                                          |
| **Chains supported**      | 1 per RPC setup                                                      | 8 networks                                               |
| **Team required**         | 2-3 blockchain engineers + DevOps                                    | Any backend engineer                                     |
| **Time to first deposit** | 3-6 months                                                           | 1-2 weeks                                                |
| **New protocol added**    | Months of development                                                | Available instantly, no code changes                     |
| **Position tracking**     | Build custom indexer                                                 | Built-in (`GET /wallets/:wallet`)                        |

<Note>
  Pods provides a **normalized API surface** across all protocols. Add a new protocol without changing your codebase — we handle the complexity.
</Note>

## Position Tracking & Data

Beyond transaction generation, Pods provides real-time position monitoring and accounting-ready data:

**Available via API:**

* Current position balances across all protocols
* Realized and unrealized PnL
* Yield earned over time (with APY breakdowns)
* Historical transaction data
* Aggregated portfolio value across chains
* Webhook notifications for status changes

**Example:**

```javascript theme={null}
const { data: positions } = await pods.get(`/wallets/${userAddress}`)

console.log('Total Portfolio Value:', positions.summary.totalUnderlyingBalanceUSD)

positions.positions.forEach(p => {
  console.log(`${p.strategy.id}: $${p.spotPosition.underlyingBalanceUSD}`)
  console.log(`  Current APY: ${(p.spotPosition.apy * 100).toFixed(2)}%`)
})
```

No need to index events, handle chain reorgs, or reconcile balances — Pods provides normalized, treated data.

## FAQ

<AccordionGroup>
  <Accordion title="Do you custody funds?" icon="shield-halved">
    **No.** Pods is non-custodial infrastructure. Your users sign transactions with their own wallets and maintain full custody. Pods never holds private keys or funds.
  </Accordion>

  <Accordion title="Do we need a Solidity team to integrate?" icon="users">
    **No.** Pods abstracts all smart contract interactions. Any backend engineer familiar with REST APIs can integrate Pods — no blockchain expertise required.
  </Accordion>

  <Accordion title="What happens if Pods goes down?" icon="triangle-exclamation">
    User funds remain safe — they're deposited directly into underlying protocols (Aave, Morpho, etc.) and are never held by Pods. Your users can always withdraw directly via protocol UIs.

    Check our live uptime: [Pods API Status](https://pods.betteruptime.com/)
  </Accordion>

  <Accordion title="Can we integrate new protocols as they launch?" icon="plus">
    **Yes.** Pods continuously adds new protocol integrations. When we add a new protocol, it becomes immediately available via the API — no client-side changes required.
  </Accordion>

  <Accordion title="Do you support testnet for development?" icon="flask">
    **Yes.** Pods provides testnet endpoints for development and testing. Contact support to enable testnet access for your API key.
  </Accordion>

  <Accordion title="How do you handle protocol upgrades?" icon="rotate">
    Pods monitors protocol upgrades and handles migrations automatically. Versioned adapters ensure backward compatibility. You'll be notified of any breaking changes well in advance.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/getting-started/quickstart">
    Add yield to your app in 5 minutes
  </Card>

  <Card title="Architecture Overview" icon="sitemap" href="/getting-started/architecture">
    Understand how Pods works
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Explore all available endpoints
  </Card>

  <Card title="Get API Key" icon="key" href="https://www.pods.finance/plg/select-plan">
    Sign up and start building
  </Card>
</CardGroup>

<Info>
  **Questions?** Reach out to our team at [support@pods.finance](mailto:support@pods.finance)
</Info>