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

# pan API

> Infraestructura que desbloquea nuevas fuentes de revenue para fintechs. Integra productos financieros avanzados con una simple API.

<Hero title="Nuevos productos. Nuevos ingresos." subtitle="pan es la infraestructura que permite a fintechs ofrecer productos financieros avanzados sin construir la complejidad internamente. Desbloquea revenue con una API." image="/images/hero-light.png" darkImage="/images/hero-dark.png" />

## ¿Por qué pan?

Las fintechs en LATAM tienen millones de usuarios pero pocas formas de monetizar sus depositos. Construir productos de rendimiento internamente requiere:

* Equipos especializados en blockchain
* Meses de desarrollo e integraciones
* Riesgo operativo y regulatorio
* Mantenimiento continuo de infraestructura

**pan te da todo esto listo para usar, con una simple API.**

<CodeGroup>
  ```javascript sin pan (100+ lineas) theme={null}
  // 1. Configurar provider
  const provider = new ethers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

  // 2. Obtener contrato de Aave
  const poolAddress = "0x794a61358D6845594F94dc1DB02A252b5b4814aD";
  const poolAbi = [...]; // ABI extenso
  const pool = new ethers.Contract(poolAddress, poolAbi, wallet);

  // 3. Aprobar tokens
  const usdc = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, wallet);
  const approveTx = await usdc.approve(poolAddress, amount);
  await approveTx.wait();

  // 4. Calcular gas, manejar errores, depositar...
  // ... 80+ líneas más de codigo
  ```

  ```javascript con pan (6 lineas) theme={null}
  import { Pan } from '@pan/sdk';

  const pan = new Pan({ apiKey: 'pan_sk_...' });

  const intent = await pan.lend({
    walletId: 'wallet_abc123',
    amount: 1000,
    asset: 'USDC'
  });
  // pan encuentra el mejor APY, hace bridges si es necesario,
  // y deposita automaticamente
  ```
</CodeGroup>

<CardGroup cols={2}>
  <Card title="Inicio Rapido" icon="rocket" href="/guias/inicio-rapido">
    Tu primera llamada API en menos de 5 minutos
  </Card>

  <Card title="Autenticación" icon="key" href="/guias/autenticacion">
    Como autenticar y asegurar tus requests
  </Card>

  <Card title="Conceptos Clave" icon="book" href="/guias/conceptos/vision-general">
    Entiende wallets, intents y planes de ejecución
  </Card>

  <Card title="Referencia API" icon="terminal" href="/api/introduccion">
    Documentación completa de todos los endpoints
  </Card>
</CardGroup>

## Características Principales

<AccordionGroup>
  <Accordion title="Wallets Multi-chain" icon="wallet">
    Crea wallets que funcionan en múltiples blockchains con una sola dirección. No necesitas manejar direcciones separadas por chain.

    ```javascript theme={null}
    const wallet = await pan.wallet.create({ userId: 'usuario_123' });
    // wallet.address funciona en Ethereum, Arbitrum, Base, etc.
    ```

    **Beneficios:**

    * Una dirección, múltiples chains
    * Custodia no-custodial via Privy
    * Balances unificados
  </Accordion>

  <Accordion title="Intents: Operaciones basadas en objetivos" icon="target">
    En lugar de especificar transacciones exactas, expresas tu objetivo y pan determina la mejor estrategia.

    ```javascript theme={null}
    // Quiero prestar 1000 USDC donde mejor pague
    const intent = await pan.lend({
      walletId: 'wallet_abc123',
      amount: 1000,
      asset: 'USDC'
      // No específicas chain - pan encuentra el mejor APY
    });
    ```

    pan automaticamente:

    * Analiza APYs en todas las chains
    * Determina si necesita hacer bridge
    * Ejecuta swaps si es necesario
    * Deposita en el protocolo optimo
  </Accordion>

  <Accordion title="Planificación Automatica" icon="route">
    El sistema inteligente de pan analiza tu wallet, evalua protocolos DeFi, y genera planes optimizados que minimizan costos de gas.

    **Ejemplo de plan generado:**

    ```json theme={null}
    {
      "strategy": "single-bridge",
      "steps": [
        { "type": "bridge", "from": "arbitrum", "to": "base", "amount": "1000" },
        { "type": "deposit", "protocol": "aave", "amount": "1000" }
      ],
      "estimatedGas": "0.002 ETH",
      "estimatedTime": "2-5 minutos"
    }
    ```
  </Accordion>

  <Accordion title="Multi-chain Nativo" icon="link">
    pan soporta múltiples chains de forma nativa:

    | Chain    | Mainnet        | Testnet            |
    | -------- | -------------- | ------------------ |
    | Ethereum | chainId: 1     | Sepolia (11155111) |
    | Arbitrum | chainId: 42161 | Sepolia (421614)   |
    | Base     | chainId: 8453  | Sepolia (84532)    |

    Consulta balances de todas las chains con una sola llamada:

    ```javascript theme={null}
    const balances = await pan.wallet.getBalances('wallet_abc123');
    // Retorna balances de ETH, Arbitrum, Base, etc.
    ```
  </Accordion>
</AccordionGroup>

## Como Funcióna

<Steps>
  <Step title="Autentica">
    Obtiene tu API key desde el dashboard e incluyela en todas tus requests usando el header `Authorization`.

    ```bash theme={null}
    Authorization: Bearer pan_sk_tu_api_key_aqui
    ```
  </Step>

  <Step title="Crea Wallets">
    Crea wallets para tus usuarios con una simple llamada. Cada wallet soporta automáticamente todas las blockchains disponibles.

    ```bash theme={null}
    POST /v1/wallets
    {
      "userId": "usuario_123",
      "metadata": { "email": "usuario@ejemplo.com" }
    }
    ```
  </Step>

  <Step title="Consulta Balances">
    Consulta balances de todas las chains y tokens con un solo endpoint. Obtiene información de activos en tiempo real incluyendo valores en USD.

    ```bash theme={null}
    GET /v1/balances/wallet_abc123
    ```
  </Step>

  <Step title="Ejecuta Intents">
    Define lo que quieres lograr (por ejemplo, "prestar \$1000 USDC"), y pan maneja toda la complejidad de swaps, bridges y depósitos automaticamente.

    ```bash theme={null}
    POST /v1/intents
    {
      "walletId": "wallet_abc123",
      "action": "lend",
      "amount": 1000,
      "asset": "USDC"
    }
    ```
  </Step>
</Steps>

## ¿Quién usa pan?

<CardGroup cols={3}>
  <Card title="Bancos" icon="building-columns">
    Ofrece productos de rendimiento a tus clientes sin construir infraestructura blockchain desde cero.
  </Card>

  <Card title="Fintechs" icon="chart-line">
    Monetiza los depósitos de tus usuarios con productos financieros avanzados a través de una simple API.
  </Card>

  <Card title="Apps de Cripto" icon="bitcoin-sign">
    Integra estrategias de yield optimizadas y operaciones multi-chain en tu plataforma.
  </Card>
</CardGroup>

## Ejemplo Completo

Este ejemplo muestra el flujo completo: crear wallet, fondear, consultar balance, y ejecutar un intent de lending:

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { Pan } from '@pan/sdk';

  // Inicializar cliente
  const pan = new Pan({ apiKey: process.env.PAN_API_KEY });

  async function ejemploCompleto() {
    // 1. Crear wallet para un usuario
    const wallet = await pan.wallet.create({
      userId: 'usuario_maria_123',
      metadata: {
        nombre: 'Maria Garcia',
        email: 'maria@ejemplo.com'
      }
    });

    console.log(`Wallet creada: ${wallet.address}`);
    // Wallet creada: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

    // 2. Consultar balances (despues de fondear externamente)
    const balances = await pan.wallet.getBalances(wallet.id);

    console.log('Balances por chain:');
    for (const chainData of balances.chains) {
      for (const token of chainData.tokens) {
        console.log(`  ${chainData.chain}: ${token.balanceFormatted} ${token.asset}`);
      }
    }
    // arbitrum: 500.00 USDC
    // base: 300.00 USDC
    // ethereum: 200.00 USDC

    // 3. Obtener mejores yields disponibles
    const { rates, best } = await pan.yields.getAll();

    console.log('Mejores APYs:');
    rates.forEach(y => {
      console.log(`  ${y.chain}: ${y.apy}% en ${y.protocol}`);
    });
    // base: 8.5% en Aave
    // arbitrum: 7.2% en Aave
    // ethereum: 5.1% en Aave

    // 4. Crear intent de lending
    // pan automaticamente:
    // - Ve que Base tiene mejor APY (8.5%)
    // - Hace bridge de los fondos de Arbitrum y Ethereum a Base
    // - Deposita todo en Aave Base
    const intent = await pan.lend({
      walletId: wallet.id,
      amount: 1000, // Todo el USDC disponible
      asset: 'USDC'
    });

    console.log(`Intent creado: ${intent.id}`);
    console.log(`Estado: ${intent.status}`);
    console.log(`Estrategia: ${intent.executionPlan?.strategy}`);

    // 5. Monitorear ejecución
    let status = intent.status;
    while (status !== 'completed' && status !== 'failed') {
      await new Promise(r => setTimeout(r, 5000));
      const updated = await pan.getIntent(intent.id);
      status = updated.status;
      console.log(`Estado actual: ${status}`);
    }

    if (status === 'completed') {
      console.log('Lending completado exitosamente!');
      console.log(`Gas total: $${intent.results.totalGasCostUsd}`);
    }
  }

  ejemploCompleto();
  ```

  ```python Python theme={null}
  import os
  import time
  import requests

  API_KEY = os.environ['PAN_API_KEY']
  BASE_URL = 'https://api.pan.tech/v1'

  headers = {
      'Authorization': f'Bearer {API_KEY}',
      'Content-Type': 'application/json'
  }

  def ejemplo_completo():
      # 1. Crear wallet
      response = requests.post(
          f'{BASE_URL}/wallets',
          headers=headers,
          json={
              'userId': 'usuario_maria_123',
              'metadata': {
                  'nombre': 'Maria Garcia',
                  'email': 'maria@ejemplo.com'
              }
          }
      )
      wallet = response.json()
      print(f"Wallet creada: {wallet['address']}")

      # 2. Consultar balances
      response = requests.get(
          f"{BASE_URL}/balances/{wallet['id']}",
          headers=headers
      )
      balances = response.json()

      print('Balances por chain:')
      for chain_data in balances['chains']:
          for token in chain_data['tokens']:
              print(f"  {chain_data['chain']}: {token['balanceFormatted']} {token['asset']}")

      # 3. Obtener yields
      response = requests.get(f'{BASE_URL}/yields', headers=headers)
      yields = response.json()

      print('Mejores APYs:')
      for y in yields['rates']:
          print(f"  {y['chain']}: {y['apy']}% en {y['protocol']}")

      # 4. Crear intent
      response = requests.post(
          f'{BASE_URL}/intents',
          headers=headers,
          json={
              'walletId': wallet['id'],
              'action': 'lend',
              'amount': 1000,
              'asset': 'USDC'
          }
      )
      intent = response.json()
      print(f"Intent creado: {intent['id']}")

      # 5. Monitorear
      status = intent['status']
      while status not in ['completed', 'failed']:
          time.sleep(5)
          response = requests.get(
              f"{BASE_URL}/intents/{intent['id']}",
              headers=headers
          )
          intent = response.json()
          status = intent['status']
          print(f"Estado actual: {status}")

      if status == 'completed':
          print('Lending completado!')

  ejemplo_completo()
  ```

  ```bash cURL theme={null}
  # 1. Crear wallet
  curl -X POST https://api.pan.tech/v1/wallets \
    -H "Authorization: Bearer $PAN_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "userId": "usuario_maria_123",
      "metadata": {
        "nombre": "Maria Garcia",
        "email": "maria@ejemplo.com"
      }
    }'

  # 2. Consultar balances
  curl -X GET https://api.pan.tech/v1/balances/wallet_abc123 \
    -H "Authorization: Bearer $PAN_API_KEY"

  # 3. Obtener yields
  curl -X GET https://api.pan.tech/v1/yields \
    -H "Authorization: Bearer $PAN_API_KEY"

  # 4. Crear intent de lending
  curl -X POST https://api.pan.tech/v1/intents \
    -H "Authorization: Bearer $PAN_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "walletId": "wallet_abc123",
      "action": "lend",
      "amount": 1000,
      "asset": "USDC"
    }'

  # 5. Monitorear estado
  curl -X GET https://api.pan.tech/v1/intents/intent_xyz789 \
    -H "Authorization: Bearer $PAN_API_KEY"
  ```
</CodeGroup>

## Empieza Ahora

<CardGroup cols={2}>
  <Card title="Obtener API Key" icon="key" href="https://app.pan.tech">
    Registrate gratis y comienza a construir en minutos
  </Card>

  <Card title="Ver Ejemplos" icon="code" href="/ejemplos/fintech-basico">
    Explora casos de uso completos con codigo
  </Card>
</CardGroup>

<Note>
  **Estado Actual**: pan API v1 soporta lending en las testnets de Ethereum Sepolia, Base Sepolia, y Arbitrum Sepolia. Soporte mainnet y funcionalidades adicionales próximamente.
</Note>