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

# Resumen

> Usa la API de Swap alojada de Raptor para cotizaciones e intercambios — sin cliente propio. Autoaloja el binario solo si necesitas tu propia instancia.

export const SelfHostDiagram = ({lang = "en"}) => {
  const T = ({
    en: {
      aria: "How the self-hosted binary connects to Solana and to your app",
      ys: "Streams pool account updates",
      rpc: "Startup reads and blockhashes",
      idx: "Pool index",
      idxSub: "Downloaded once at startup",
      server: "Your server",
      core: "Keeps every pool in memory, so quotes never wait on RPC",
      app: "Your app",
      appSub: "HTTP and WebSocket on port 8080"
    },
    cn: {
      aria: "自托管二进制如何连接 Solana 与你的应用",
      ys: "流式推送池账户更新",
      rpc: "启动时读取与区块哈希",
      idx: "池索引",
      idxSub: "启动时下载一次",
      server: "你的服务器",
      core: "所有池都保存在内存中，报价无需等待 RPC",
      app: "你的应用",
      appSub: "端口 8080 上的 HTTP 与 WebSocket"
    },
    es: {
      aria: "Cómo se conecta el binario autoalojado a Solana y a tu app",
      ys: "Transmite actualizaciones de cuentas de pools",
      rpc: "Lecturas al arrancar y blockhashes",
      idx: "Índice de pools",
      idxSub: "Se descarga una vez al arrancar",
      server: "Tu servidor",
      core: "Mantiene todos los pools en memoria, así las cotizaciones nunca esperan al RPC",
      app: "Tu app",
      appSub: "HTTP y WebSocket en el puerto 8080"
    }
  })[lang];
  return <figure className="rg not-prose" aria-label={T.aria}>
    <div className="rg-stage rg-host">
      <div className="rg-host-col">
        <div className="rg-host-box">
          <span className="rg-title">Yellowstone gRPC</span>
          <span className="rg-host-sub">{T.ys}</span>
        </div>
        <div className="rg-host-box">
          <span className="rg-title">Solana RPC</span>
          <span className="rg-host-sub">{T.rpc}</span>
        </div>
        <div className="rg-host-box">
          <span className="rg-title">{T.idx}</span>
          <span className="rg-host-sub">{T.idxSub}</span>
        </div>
      </div>
      <div className="rg-host-arrow" aria-hidden="true"><span /></div>
      <div className="rg-host-core">
        <span className="rg-chip rg-chip-accent">{T.server}</span>
        <span className="rg-host-name">raptor</span>
        <span className="rg-host-sub">{T.core}</span>
        <div className="rg-host-tags"><span>quote</span><span>swap</span><span>stream</span><span>send</span></div>
      </div>
      <div className="rg-host-arrow rg-host-arrow-both" aria-hidden="true"><span /></div>
      <div className="rg-host-col">
        <div className="rg-host-box">
          <span className="rg-title">{T.app}</span>
          <span className="rg-host-sub">{T.appSub}</span>
        </div>
      </div>
    </div>
  </figure>;
};

export const ArbitrageCycle = ({lang = "en"}) => {
  const T = ({
    en: {
      aria: "An arbitrage cycle from SOL through USDC and JitoSOL back to SOL",
      in: "In",
      a: "After HumidiFi",
      b: "After Orca",
      out: "Out",
      note: "Illustration with example numbers. Profit is before network and priority fees."
    },
    cn: {
      aria: "从 SOL 经 USDC 和 JitoSOL 回到 SOL 的套利循环",
      in: "投入",
      a: "经 HumidiFi 后",
      b: "经 Orca 后",
      out: "产出",
      note: "示意图，数字仅为示例。利润未扣除网络费和优先费。"
    },
    es: {
      aria: "Un ciclo de arbitraje de SOL a USDC y JitoSOL y de vuelta a SOL",
      in: "Entrada",
      a: "Tras HumidiFi",
      b: "Tras Orca",
      out: "Salida",
      note: "Ilustración con números de ejemplo. La ganancia es antes de las comisiones de red y de prioridad."
    }
  })[lang];
  const NODES = [{
    id: "SOL",
    x: 180,
    y: 40
  }, {
    id: "USDC",
    x: 316,
    y: 220
  }, {
    id: "JitoSOL",
    x: 44,
    y: 220
  }];
  const EDGES = [{
    from: 0,
    to: 1,
    pool: "HumidiFi",
    lx: 262,
    ly: 122,
    anchor: "start"
  }, {
    from: 1,
    to: 2,
    pool: "Orca Whirlpool",
    lx: 180,
    ly: 258,
    anchor: "middle"
  }, {
    from: 2,
    to: 0,
    pool: "Sanctum Infinity",
    lx: 98,
    ly: 122,
    anchor: "end"
  }];
  const R = 27;
  const seg = (p, q) => {
    const dx = q.x - p.x, dy = q.y - p.y, d = Math.hypot(dx, dy);
    const ux = dx / d, uy = dy / d;
    return {
      x1: p.x + ux * (R + 4),
      y1: p.y + uy * (R + 4),
      x2: q.x - ux * (R + 6),
      y2: q.y - uy * (R + 6)
    };
  };
  return <figure className="rg not-prose" aria-label={T.aria}>
      <div className="rg-stage rg-arb">
        <svg viewBox="0 0 360 272" className="rg-arb-svg" aria-hidden="true">
          <defs>
            <marker id="rg-arb-head" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto">
              <path d="M1,1 L9,5 L1,9" className="rg-arrowhead" />
            </marker>
          </defs>
          {EDGES.map(e => {
    const s = seg(NODES[e.from], NODES[e.to]);
    return <g key={e.pool}>
                <line x1={s.x1} y1={s.y1} x2={s.x2} y2={s.y2} className="rg-edge" markerEnd="url(#rg-arb-head)" />
                <text x={e.lx} y={e.ly} textAnchor={e.anchor} className="rg-edge-label">{e.pool}</text>
              </g>;
  })}
          {NODES.map((n, i) => <g key={n.id}>
              <circle cx={n.x} cy={n.y} r={R} className={i === 0 ? "rg-node rg-node-home" : "rg-node"} />
              <text x={n.x} y={n.y + 4} textAnchor="middle" className="rg-node-text">{n.id}</text>
            </g>)}
        </svg>
        <div className="rg-arb-side">
          <div className="rg-ledger">
            <div><span className="rg-label">{T.in}</span><span>1.000000 SOL</span></div>
            <div><span className="rg-label">{T.a}</span><span>182.4120 USDC</span></div>
            <div><span className="rg-label">{T.b}</span><span>0.848100 JitoSOL</span></div>
            <div className="rg-ledger-out"><span className="rg-label">{T.out}</span><span>1.001240 SOL</span></div>
          </div>
          <span className="rg-pill">+0.001240 SOL</span>
        </div>
      </div>
      <figcaption className="rg-note">{T.note}</figcaption>
    </figure>;
};

export const SwapFlow = ({lang = "en"}) => {
  const T = ({
    en: {
      aria: "Swap flow: quote, build, sign, send, confirm",
      wallet: "User's wallet",
      steps: [["Quote", "Find the best route. No wallet needed."], ["Build", "Turn the quote into a transaction."], ["Sign", "Only the user's key signs it."], ["Send", "Raptor delivers it to the block leaders."], ["Confirm", "Check that it landed."]]
    },
    cn: {
      aria: "兑换流程：报价、构建、签名、发送、确认",
      wallet: "用户钱包",
      steps: [["报价", "找到最佳路由，无需钱包。"], ["构建", "把报价转换为交易。"], ["签名", "只有用户的私钥能签名。"], ["发送", "Raptor 将交易发送给出块节点。"], ["确认", "检查交易是否上链。"]]
    },
    es: {
      aria: "Flujo del swap: cotizar, construir, firmar, enviar, confirmar",
      wallet: "Wallet del usuario",
      steps: [["Cotizar", "Encuentra la mejor ruta. No necesita wallet."], ["Construir", "Convierte la cotización en una transacción."], ["Firmar", "Solo la clave del usuario la firma."], ["Enviar", "Raptor la entrega a los líderes de bloque."], ["Confirmar", "Comprueba que se ejecutó."]]
    }
  })[lang];
  const CALLS = ["GET /quote", "POST /swap", T.wallet, "POST /send-transaction", "GET /transaction/{sig}"];
  const STEPS = T.steps.map(([title, note], i) => ({
    title,
    note,
    call: CALLS[i],
    wallet: i === 2
  }));
  return <figure className="rg not-prose" aria-label={T.aria}>
      <div className="rg-stage">
        <ol className="rg-flow">
          {STEPS.map((s, i) => <li key={s.title} className={s.wallet ? "rg-flow-step rg-flow-wallet" : "rg-flow-step"}>
              <span className="rg-flow-dot">{i + 1}</span>
              <span className="rg-flow-title">{s.title}</span>
              <span className="rg-flow-call">{s.call}</span>
              <span className="rg-flow-note">{s.note}</span>
            </li>)}
        </ol>
      </div>
    </figure>;
};

export const JitRouting = ({lang = "en"}) => {
  const T = ({
    en: {
      aria: "A standard route compared with Raptor JIT routing on the same swap",
      std: "Standard route",
      locked: "Locked at quote",
      receive: "You receive",
      quoted: "Quoted",
      landed: "Landed",
      jit: "Raptor JIT",
      priced: "Priced at execution",
      stdText: "The pools are fixed when you quote. If prices move before the transaction lands, you get less.",
      jitText: "The transaction carries candidate pools. Raptor re-prices them on-chain as it lands and splits the order across the best.",
      pre: "",
      pill: " USDC on the same swap",
      note: "Illustration with example numbers. Real results depend on the order and on how prices move."
    },
    cn: {
      aria: "同一笔兑换中普通路由与 Raptor JIT 路由的对比",
      std: "普通路由",
      locked: "报价时锁定",
      receive: "实际到手",
      quoted: "报价",
      landed: "上链",
      jit: "Raptor JIT",
      priced: "执行时定价",
      stdText: "池子在报价时就已固定。如果交易上链前价格变动，你拿到的就会更少。",
      jitText: "交易携带多个候选池。Raptor 在交易上链时于链上重新定价，并把订单拆分到最优的池子。",
      pre: "同一笔兑换多得 ",
      pill: " USDC",
      note: "示意图，数字仅为示例。实际结果取决于订单和价格变动。"
    },
    es: {
      aria: "Una ruta estándar comparada con el JIT routing de Raptor en el mismo swap",
      std: "Ruta estándar",
      locked: "Fijada al cotizar",
      receive: "Recibes",
      quoted: "Cotizado",
      landed: "Ejecutado",
      jit: "Raptor JIT",
      priced: "Precio al ejecutar",
      stdText: "Los pools se fijan al cotizar. Si los precios se mueven antes de que la transacción se ejecute, recibes menos.",
      jitText: "La transacción lleva varios pools candidatos. Raptor los vuelve a cotizar on-chain al ejecutarse y reparte la orden entre los mejores.",
      pre: "",
      pill: " USDC en el mismo swap",
      note: "Ilustración con números de ejemplo. Los resultados reales dependen de la orden y de cómo se muevan los precios."
    }
  })[lang];
  const QUOTE = 36412.18, FIXED = 36389.4, JIT = 36418.95;
  const fmt = v => v.toLocaleString("en-US", {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2
  });
  const drift = u => QUOTE + (FIXED - QUOTE) * u * u * (3 - 2 * u) + 2.6 * Math.sin(u * Math.PI * 5) * Math.sin(u * Math.PI);
  const W = 300, H = 92, vMin = 36382, vMax = 36420;
  const y = v => 6 + (H - 12) * (1 - (v - vMin) / (vMax - vMin));
  const path = Array.from({
    length: 61
  }, (_, i) => (i ? "L" : "M") + (W * i / 60).toFixed(1) + "," + y(drift(i / 60)).toFixed(1)).join(" ");
  const CANDIDATES = [{
    name: "HumidiFi",
    alloc: 62
  }, {
    name: "Tessera",
    alloc: 38
  }, {
    name: "SolFi V2",
    alloc: 0
  }, {
    name: "GoonFi V2",
    alloc: 0
  }, {
    name: "AlphaQ",
    alloc: 0
  }];
  return <figure className="rg not-prose" aria-label={T.aria}>
      <div className="rg-stage">
        <div className="rg-pair">
          <div className="rg-card">
            <div className="rg-head"><span className="rg-title">{T.std}</span><span className="rg-chip">{T.locked}</span></div>
            <div className="rg-label">{T.receive}</div>
            <div className="rg-big"><span>{fmt(FIXED)}</span><span className="rg-delta rg-neg">−{fmt(QUOTE - FIXED)}</span></div>
            <svg className="rg-spark" viewBox={"0 0 " + W + " " + H} preserveAspectRatio="none" aria-hidden="true">
              <line x1="0" x2={W} y1={y(QUOTE)} y2={y(QUOTE)} className="rg-quote-line" />
              <path d={path} className="rg-spark-path" />
            </svg>
            <div className="rg-axis"><span>{T.quoted + " " + fmt(QUOTE)}</span><span>{T.landed}</span></div>
            <p className="rg-explain">{T.stdText}</p>
          </div>

          <div className="rg-card rg-card-accent">
            <div className="rg-head"><span className="rg-title">{T.jit}</span><span className="rg-chip rg-chip-accent">{T.priced}</span></div>
            <div className="rg-label">{T.receive}</div>
            <div className="rg-big"><span className="rg-pos">{fmt(JIT)}</span><span className="rg-delta rg-pos">+{fmt(JIT - QUOTE)}</span></div>
            <div className="rg-rows">
              {CANDIDATES.map(c => <div key={c.name} className={c.alloc ? "rg-row rg-row-on" : "rg-row"}>
                  <span className="rg-name">{c.name}</span>
                  <span className="rg-track"><i style={{
    width: c.alloc + "%"
  }} /></span>
                  <span className="rg-alloc">{c.alloc ? c.alloc + "%" : "—"}</span>
                </div>)}
            </div>
            <p className="rg-explain">{T.jitText}</p>
          </div>
        </div>
        <div className="rg-foot"><span className="rg-pill">{T.pre + "+" + fmt(JIT - FIXED) + T.pill}</span></div>
      </div>
      <figcaption className="rg-note">{T.note}</figcaption>
    </figure>;
};

export const RaptorStatus = ({lang = "en"}) => {
  const T = ({
    en: {
      badge: "Out of beta",
      text: "Raptor V1 is live on mainnet, with JIT routing across 71 DEXes.",
      link: "What's new",
      href: "/raptor/recent-changes"
    },
    cn: {
      badge: "已结束测试",
      text: "Raptor V1 已在主网正式上线，支持 71 个 DEX 的 JIT 路由。",
      link: "查看更新",
      href: "/cn/raptor/recent-changes"
    },
    es: {
      badge: "Fuera de beta",
      text: "Raptor V1 ya está en mainnet, con JIT routing en 71 DEXes.",
      link: "Novedades",
      href: "/es/raptor/recent-changes"
    }
  })[lang];
  return <div className="rg rg-status not-prose">
      <span className="rg-status-badge"><i />{T.badge}</span>
      <span className="rg-status-text">{T.text}</span>
      <a className="rg-status-link" href={T.href}>{T.link} →</a>
    </div>;
};

<RaptorStatus lang="es" />

<Note>
  Únete al [Discord](https://discord.gg/JH2e9rR9fc) para consultas de soporte.
  Raptor es actualmente gratis y sin límites de tasa.
</Note>

## Cómo usar Raptor

**No necesitas ejecutar un cliente ni servidor de Raptor.** Llama a la API alojada de Solana Tracker desde tu app, backend o bot: obtén cotizaciones, construye transacciones de swap, fírmalas en la wallet del usuario y envíalas. Sin binario, sin configurar RPC ni operar un indexador de pools.

<SwapFlow lang="es" />

<Info>
  **API alojada (recomendada para la mayoría de integraciones)**

  * **HTTP:** `https://raptor.solanatracker.io`
  * **WebSocket:** `wss://raptor.solanatracker.io`

  Empieza con la [guía Swap API](/es/guides/swap-api) para el flujo completo y ejemplos listos para copiar. Consulta la [referencia HTTP](/es/raptor/http/get-swap-quote) y la sección [WebSocket](#websocket) más abajo para cada endpoint.
</Info>

<CardGroup cols={2}>
  <Card title="Guía Swap API" icon="https://mintcdn.com/solanatracker/l0aXlX5jJ7xpUiwY/icons/hugeicons/book-open.svg?fit=max&auto=format&n=l0aXlX5jJ7xpUiwY&q=85&s=c657b9b7c4d3c1b7c614737467c02d00" iconType="duotone" href="/es/guides/swap-api" width="24" height="24" data-path="icons/hugeicons/book-open.svg">
    Paso a paso: cotización → construir → firmar → enviar. Con curl, fetch y WebSockets.
  </Card>

  <Card title="Enviar transacciones" icon="https://mintcdn.com/solanatracker/4PIKDaYde_747jyk/icons/hugeicons/paper-plane.svg?fit=max&auto=format&n=4PIKDaYde_747jyk&q=85&s=3be92993f8322687bf0dd345de6f8140" iconType="duotone" href="/es/raptor/transactions" width="24" height="24" data-path="icons/hugeicons/paper-plane.svg">
    Envía swaps firmados y sigue el estado de confirmación.
  </Card>
</CardGroup>

<Note>
  **Autoalojamiento (opcional)** — Solo si quieres tu propia instancia de Raptor. Release binario: [GitHub](https://github.com/solanatracker/raptor-binary). Flags CLI y variables de entorno en [Autoalojamiento (opcional)](#autoalojamiento-opcional) más abajo.
</Note>

## JIT routing

Una ruta normal elige sus pools al cotizar. Con el routing just-in-time (JIT), la transacción lleva varios pools candidatos y elige los mejores al ejecutarse, con precios en vivo. Ayuda sobre todo en órdenes grandes y en pools que se mueven rápido.

<JitRouting lang="es" />

| `jitRouting` | Comportamiento |
| - | - |
| `auto` (por defecto) | Raptor usa JIT cuando mejora el resultado. Las órdenes de unos \$10,000 o más reciben una búsqueda completa. |
| `true` | Siempre construye una ruta JIT |
| `false` | Nunca usa JIT |

Las cotizaciones que usan JIT incluyen `"jitRouting": true`. A tener en cuenta:

* **`minAmountOut` se sigue aplicando.** Si los precios en vivo no lo alcanzan, la transacción falla en lugar de ejecutarse a peor precio.
* **JIT funciona con transacciones `V0` y `V1`.** Las transacciones `LEGACY` no tienen tablas de búsqueda y su límite es de 1.232 bytes, así que las rutas JIT rara vez caben; cotiza con `jitRouting=false` si necesitas `LEGACY`.
* **Los swaps JIT no se pueden llamar desde otro programa.** `/swap-instructions` devuelve un swap normal salvo que envíes `jitRouting: true`. Cuando devuelve `topLevelOnly: true`, pon `swapInstruction` al final de la transacción y llámala directamente, no por CPI. Si no, falla con `InvalidJitPlan` (6026).
* JIT está disponible en todos los DEX soportados excepto Heaven, SolFi V1, BisonFi y Quantum.

***

## Endpoints

El flujo básico de Raptor es simple: obtén una cotización, construye una transacción, fírmala con la wallet del usuario, envíala y sigue el estado.

### Swap

| Endpoint | Descripción |
| - | - |
| `GET /quote` | Obtén la cantidad de salida esperada y la ruta antes de construir una transacción |
| `POST /swap` | Construye transacciones de swap completas con cálculo de priority fee, overrides de compute budget, propinas SOL opcionales y soporte para cuenta de destino |
| `POST /swap-instructions` | Construye solo las instrucciones de swap (sin wrapper de transacción) |
| `POST /quote-and-swap` | Cotización y swap combinados en una sola solicitud con propinas, configuración de fee y ajuste de transacción opcionales (feature opcional) |
| `POST /send-transaction` | Envía transacciones vía Yellowstone Jet TPU con reenvío automático y tracking de confirmación |
| `GET /transaction/:signature` | Sigue el estado de transacciones enviadas, latencia y eventos parseados |

### Analytics

| Endpoint | Descripción |
| - | - |
| `GET /health` | Health check con estado detallado (pools, cache, conexión Yellowstone) |

***

## WebSocket

| Feature | Detalles |
| - | - |
| `/stream` | Streaming de cotizaciones en tiempo real con gestión de suscripción |
| `/stream/swap` | Cotizaciones de swap en vivo con transacciones preconstruidas (listas para firmar), incluido soporte de tip |
| Updates por slot | Recálculo automático de cotización en cambios de estado de pool |
| Reenvío por inactividad | `/stream/swap` reenvía la última transacción de swap tras 10 slots sin actualización para ayudar a evitar la expiración |

***

<Info>
  **ID del programa - Mainnet:** `RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87`
</Info>

## DEXs soportados

### Raydium

* Raydium AMM
* Raydium CLMM
* Raydium CPMM
* Raydium LaunchLab/Launchpad

### Meteora

* Meteora DLMM
* Meteora Dynamic AMM
* Meteora DAMM (Dynamic AMM V2)
* Meteora Curve
* Meteora DBC (Dynamic Bonding Curve)

### Orca

* Whirlpool (legacy)
* Whirlpool V2

### Bonding Curves

* Pump.fun
* Pumpswap
* Heaven (Buy/Sell)
* MoonIt (Buy/Sell)
* Boopfun (Buy/Sell)

### PropAMM

* Humidifi
* Tessera
* Solfi V1/V2
* AlphaQ
* ZeroFi
* BisonFi
* GoonFi V2

### Otros

* FluxBeam
* PancakeSwap V3

***

## Routing

### Multi-Hop

* Rutas hasta de 4 saltos para mejor pricing
* Cálculo de slippage consciente de la ruta (considera riesgo multi-hop)
* Preferencias de routing específicas por DEX
* Filtrado de pools por listas de direcciones
* Allowlists de mints vía archivos txt
* Modo solo rutas directas (`onlyDirectRoutes` / `maxHops=1`)
* Opción de arbitraje circular

### Arbitraje

Cotiza con el mismo mint de entrada y salida, por ejemplo SOL a SOL, y Raptor busca un ciclo a través de varios pools que devuelva más de lo que pusiste.

<ArbitrageCycle lang="es" />

* Si `routePlan` no está vacío, Raptor encontró un ciclo. `amountOut` menos `amount` es la ganancia esperada, antes de las comisiones de red y de prioridad. Constrúyelo y envíalo como cualquier otro swap.
* Si ningún ciclo es rentable, la respuesta trae `routePlan` vacío y `amountOut` igual a `amount`. No hay nada que construir.
* En una instancia autoalojada, arranca el binario con `--enable-arbitrage`.

### Slippage

* Slippage dinámico basado en volatilidad y complejidad de la ruta
* Ajuste de slippage multi-hop consciente de la ruta
* Override manual de slippage (numérico o `"dynamic"`)
* Cálculo de cantidad mínima de salida con protección de slippage

### Platform Fees

* Fee tomada del input O del output
* Basis points configurables (hasta 10%)
* Especificación de wallet de fees
* Cargo extra sobre slippage positivo
* Ajuste automático de fees en cotizaciones y swaps

### Tips y controles de transacción

* Tips opcionales en SOL nativo vía `tipAccount` y `tipLamports`
* Selección de versión de transacción (`V0` o `LEGACY`)
* Override de compute unit price (`computeUnitPriceMicroLamports`)
* Override del compute unit limit (`computeUnitLimit`)
* Topes de priority fee máximo (`maxPriorityFee`)
* Override opcional de cuenta de destino (`destinationTokenAccount`)

***

## Priority Fees

### Cálculo dinámico

* Cálculo de priority fee específico de la ruta
* Ajustes de fee específicos por DEX
* Tracking de datos recientes de fees (slots tracked, total fees)
* Caps de fee máximo y overrides

### Niveles de prioridad

| Nivel | Caso de uso |
| - | - |
| `Min` / `Low` | Ahorro de costes |
| `Auto` / `Medium` | Predeterminado recomendado |
| `High` / `VeryHigh` | Prioridad de velocidad |
| `Turbo` / `UnsafeMax` | Velocidad máxima |

***

## Gestión de transacciones

### Yellowstone Jet TPU

* Envío de transacciones
* Reenvío automático alineado por slot
* Soporte multi-identidad (4 por defecto, configurable)

### Tracking

* Monitorización en tiempo real (`pending` / `confirmed` / `failed` / `expired`)
* Medición de latencia (envío a confirmación)
* Eventos parseados del programa Raptor
* Almacenamiento de transacción cruda
* Limpieza automática

### Rate Limiting

* RPS configurable (en general usa pocas llamadas RPC)

***

## Autoalojamiento (opcional)

Las secciones siguientes aplican solo si ejecutas el [binario de Raptor](https://github.com/solanatracker/raptor-binary) por tu cuenta. Si usas la API alojada de arriba, puedes ignorar flags CLI y variables de entorno.

<SelfHostDiagram lang="es" />

### Flags de CLI

### Ayuda y versión

```
-h, --help       Show help message
-v, --version    Show version information
```

### Pool Indexer

```
--no-pool-indexer          Disable pool indexer client (Yellowstone only)
--skip-pool-indexer-wait   Skip startup wait for pool indexer sync readiness
```

### Filtros de routing

```
--include-dexes <DEXES>    Only include these DEXes (comma-separated)
--exclude-dexes <DEXES>    Exclude these DEXes (comma-separated)
--include-mints-file <PATH>  Only use pools touching mints in this txt file
--include-pools-file <PATH>  Only use pools listed in this txt file
```

### Formato del archivo de allowlist

Tanto `--include-mints-file` como `--include-pools-file` esperan un archivo de texto plano con un pubkey por línea.

Ejemplo:

```text theme={null}
So11111111111111111111111111111111111111112
EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
# comments are allowed
```

* Las líneas vacías se ignoran
* `#` inicia un comentario
* Las allowlists de mints conservan cualquier pool en el que `token_a` o `token_b` coincida con un mint listado
* Las allowlists de pools conservan solo las direcciones de pool listadas exactamente
* Si se usan junto con filtros de DEX, ambos filtros aplican

### Rendimiento

```
--workers <N>              Number of worker threads (default: CPU cores)
--low-memory               Enable low-memory mode with automatic cache clearing
--memory-limit <MB>        Memory limit in MB (default: 80% of system RAM)
```

### Feature toggles

```
--enable-arbitrage         Enable circular arbitrage (same input/output mint)
-s, --enable-quote-and-swap    Enable the /quote-and-swap endpoint
--rpc-rate-limit <N>       Limit RPC calls to N per second (default: unlimited)
--enable-yellowstone-jet   Enable Yellowstone Jet TPU sender for /send-transaction
--enable-websocket         Enable WebSocket streaming quotes at /stream
```

### Yellowstone Jet TPU

```
--jet-identity <PATH>      Path to identity keypair for Jet TPU (optional)
--jet-identities <N>       Number of random identities for Jet (default: 4)
--tx-cache-ttl <SECS>      Transaction cache TTL in seconds (default: 30)
--tx-pending-expiry <SECS> Pending transaction expiry in seconds (default: 120)
```

***

## Opciones de solicitud

Campos comunes para construcción de swap soportados por `POST /swap`, `POST /quote-and-swap` y suscripciones de `/stream/swap`:

* `dexes` — allowlist de DEX separada por comas
* `pools` — allowlist de pools separada por comas
* `maxHops` — profundidad máxima de ruta (1-4)
* `onlyDirectRoutes` — forzar solo rutas directas
* `feeAccount`, `feeBps`, `feeFromInput`, `chargeBps` — controles de platform fee
* `priorityFee`, `maxPriorityFee` — control de priority fee dinámico o fijo
* `computeUnitPriceMicroLamports`, `computeUnitLimit` — overrides de compute budget
* `txVersion`, `asLegacyTransaction` — controles de formato de transacción
* `tipAccount`, `tipLamports` — transferencia opcional de tip en SOL
* `destinationTokenAccount` — cuenta de destino personalizada para el token de salida

***

## Variables de entorno

### Equivalentes de flags de CLI

| Variable | Flag |
| - | - |
| `NO_POOL_INDEXER` | `--no-pool-indexer` |
| `SKIP_POOL_INDEXER_WAIT` | `--skip-pool-indexer-wait` |
| `INCLUDE_DEXES` | `--include-dexes` |
| `EXCLUDE_DEXES` | `--exclude-dexes` |
| `INCLUDE_MINTS_FILE` | `--include-mints-file` |
| `INCLUDE_POOLS_FILE` | `--include-pools-file` |
| `WORKER_THREADS` | `--workers` |
| `ENABLE_ARBITRAGE` | `--enable-arbitrage` |
| `ENABLE_QUOTE_AND_SWAP` | `--enable-quote-and-swap` |
| `RPC_RATE_LIMIT` | `--rpc-rate-limit` |
| `ENABLE_YELLOWSTONE_JET` | `--enable-yellowstone-jet` |
| `JET_IDENTITY` | `--jet-identity` |
| `JET_NUM_IDENTITIES` | `--jet-identities` |
| `TX_CACHE_TTL_SECS` | `--tx-cache-ttl` |
| `TX_PENDING_EXPIRY_SECS` | `--tx-pending-expiry` |
| `ENABLE_WEBSOCKET` | `--enable-websocket` |
| `LOW_MEMORY_MODE` | `--low-memory` |
| `MEMORY_LIMIT_MB` | `--memory-limit` |

### Variables adicionales

| Variable | Descripción |
| - | - |
| `RPC_URL` | Endpoint RPC de Solana |
| `YELLOWSTONE_ENDPOINT` | Endpoint gRPC de Yellowstone |
| `YELLOWSTONE_TOKEN` | Token de auth de Yellowstone (opcional) |
| `BIND_ADDR` | Dirección de bind del servidor (por defecto: `0.0.0.0:8080`) |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.