> ## 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.

# Autoalojar la API de swap de Raptor para Solana

> Descarga gratis el binario de Raptor desde GitHub y ejecuta la misma API de swap en tus servidores. Sin API key y sin límites de solicitudes ni instancias.

Raptor también es un único binario que ejecutas en tus propios servidores. Usa el mismo motor de routing y la misma API [HTTP](https://docs.solanatracker.io/es/raptor/http/get-swap-quote.md) y [WebSocket](#websocket-streaming) que el servicio alojado en `raptor.solanatracker.io`.

* **Actualmente gratis.** No se cobra por el binario ni hace falta API key o clave de licencia. Descárgalo y ejecútalo.
* **Sin límites.** Ejecuta todas las instancias que quieras y atiende tantas solicitudes como admita tu hardware.
* **Puedes revenderlo.** Pon tu propia API delante, cobra por el acceso o añade tu propia [platform fee](https://docs.solanatracker.io/es/raptor/overview.md#platform-fees).

> [card] [Descargar desde GitHub](https://github.com/solanatracker/raptor-binary/releases/latest)
>
> La última versión para Linux y macOS, con checksums y notas de la versión.

> [card] [Informar de un problema](https://github.com/solanatracker/raptor-binary/issues)
>
> Los bugs y las solicitudes de funciones van al repositorio de GitHub. Las preguntas, a Discord.

> [!NOTE]
>
> No necesitas autoalojar para usar Raptor. La [API alojada](https://docs.solanatracker.io/es/raptor/overview.md), también gratis por ahora, no requiere configuración. Autoaloja cuando quieras tu propia capacidad, tu propia infraestructura o no depender de un servicio compartido.

## Qué hace el binario

De entrada, el binario sirve cotizaciones y construye transacciones de swap. Otras cuatro funciones están desactivadas hasta que las actives.

| Función | Endpoints | Por defecto | Se activa con |
| - | - | - | - |
| Cotizaciones en todos los [DEX soportados](https://docs.solanatracker.io/es/raptor/overview.md#supported-dexs), con routing multi-hop, dividido y [JIT](https://docs.solanatracker.io/es/raptor/overview.md#jit-routing) | `GET /quote` | Activado | |
| Construcción de transacciones de swap, con priority fees, tips y platform fees | `POST /swap`, `POST /swap-instructions` | Activado | |
| Comprobaciones de salud y disponibilidad | `GET /health`, `GET /ready` | Activado | |
| [Streaming de cotizaciones en vivo](#websocket-streaming) | `/stream`, `/stream/swap` | Desactivado | `--enable-websocket` |
| [Envío y seguimiento de transacciones](#send-and-track-transactions) | `POST /send-transaction`, `GET /transaction/{signature}` | Desactivado | `--enable-yellowstone-jet` |
| [Cotización y construcción en una sola llamada](#quote-and-swap-in-one-call) | `POST /quote-and-swap` | Desactivado | `--enable-quote-and-swap` |
| [Cotizaciones de arbitraje](https://docs.solanatracker.io/es/raptor/overview.md#arbitrage), con el mismo mint de entrada y salida | `GET /quote` | Desactivado | `--enable-arbitrage` |

Una solicitud a un endpoint desactivado devuelve `404`.

Raptor mantiene al día el estado de los pools con las actualizaciones de cuentas que recibe de Yellowstone gRPC, así que usa muy poco RPC después del arranque.

Yellowstone gRPC
Transmite actualizaciones de cuentas de pools

Solana RPC
Lecturas al arrancar y blockhashes

Índice de pools
Se descarga una vez al arrancar

Tu servidor
raptor
Mantiene todos los pools en memoria, así las cotizaciones nunca esperan al RPC

quoteswapstreamsend

Tu app
HTTP y WebSocket en el puerto 8080

## Requisitos

* **Un servidor Linux o macOS.**
  * Linux: x86-64 con glibc 2.30 o posterior, como Ubuntu 20.04+, Debian 11+ o RHEL 9+.
  * macOS: Apple Silicon o Intel.
* **Un endpoint RPC de Solana**, definido como `RPC_URL`.
* **Un endpoint gRPC de Yellowstone**, definido como `YELLOWSTONE_ENDPOINT`, más `YELLOWSTONE_TOKEN` si tu proveedor lo requiere. Raptor no arranca sin él.
* **Un directorio con permisos de escritura para la caché de pools.** Por defecto es `.r_cache`, junto al binario. Define `RAPTOR_POOL_DATA_DIR` para usar otro directorio.
* **HTTPS saliente.** Al arrancar, Raptor descarga el índice actual de pools desde Solana Tracker y luego lo mantiene al día con Yellowstone.

## Instalación

**1. Elige el archivo para tu servidor**

Cada [versión](https://github.com/solanatracker/raptor-binary/releases/latest) incluye un zip por plataforma, llamado `raptor-<version>-<platform>.zip`.

| Servidor | Plataforma en el nombre del archivo |
| - | - |
| Linux, x86-64 | `x86_64-unknown-linux-gnu` |
| macOS, Apple Silicon | `aarch64-apple-darwin` |
| macOS, Intel | `x86_64-apple-darwin` |

**2. Descárgalo y verifícalo**

Estos comandos descargan la última versión y la comparan con el `checksums.txt` publicado.

```bash Linux theme={null}
VERSION=$(curl -s https://api.github.com/repos/solanatracker/raptor-binary/releases/latest \
  | grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4)
PLATFORM=x86_64-unknown-linux-gnu
BASE=https://github.com/solanatracker/raptor-binary/releases/download/$VERSION

curl -LO "$BASE/raptor-$VERSION-$PLATFORM.zip"
curl -LO "$BASE/checksums.txt"
sha256sum --check --ignore-missing checksums.txt
unzip "raptor-$VERSION-$PLATFORM.zip"
```

```bash macOS theme={null}
VERSION=$(curl -s https://api.github.com/repos/solanatracker/raptor-binary/releases/latest \
  | grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4)
PLATFORM=aarch64-apple-darwin   # x86_64-apple-darwin on Intel Macs
BASE=https://github.com/solanatracker/raptor-binary/releases/download/$VERSION

curl -LO "$BASE/raptor-$VERSION-$PLATFORM.zip"
curl -LO "$BASE/checksums.txt"
shasum -a 256 --check --ignore-missing checksums.txt
unzip "raptor-$VERSION-$PLATFORM.zip"
```

La comprobación imprime `raptor-<version>-<platform>.zip: OK`. Si imprime otra cosa, borra el zip y vuelve a descargarlo.

Deja `raptor.sig` en el mismo directorio que `raptor`. El binario lo usa para comprobar que no se ha modificado.

**3. Comprueba que se ejecuta**

```bash theme={null}
./raptor --version
```

Si macOS bloquea un binario descargado desde el navegador, quita la marca de cuarentena con `xattr -d com.apple.quarantine raptor`.

## Ejecución

Define tus endpoints e inicia el servidor.

```bash theme={null}
export RPC_URL="https://your-rpc.example.com"
export YELLOWSTONE_ENDPOINT="https://your-grpc.example.com"
export YELLOWSTONE_TOKEN="your-token"

./raptor
```

Raptor escucha en `0.0.0.0:8080`. Define `BIND_ADDR` para cambiarlo, por ejemplo `BIND_ADDR=127.0.0.1:9000`.

Para activar todas las funciones opcionales excepto el arbitraje:

```bash theme={null}
./raptor --enable-websocket --enable-yellowstone-jet --enable-quote-and-swap
```

### Espera a que esté listo

Raptor indexa los pools antes de poder enrutar. Hasta que termina, `/quote` devuelve `503` con `Server warming up`. `/ready` devuelve `200` cuando Raptor ya puede servir cotizaciones, y `503` antes de eso:

```bash theme={null}
curl http://localhost:8080/ready
```

```json theme={null}
{ "ready": true, "pool_count": 812345, "indexed_count": 812345, "indexing_in_progress": false }
```

`/health` devuelve `OK` en cuanto el servidor arranca, aunque siga indexando. Apunta los health checks del balanceador de carga a `/ready` para que cada instancia reciba tráfico solo cuando ya pueda cotizar.

### Haz tu primera cotización

```bash theme={null}
curl "http://localhost:8080/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50"
```

Todos los ejemplos del [resumen](https://docs.solanatracker.io/es/raptor/overview.md) funcionan en tu instancia si sustituyes `https://raptor.solanatracker.io` por la dirección de tu servidor.

## Funciones opcionales

Cada flag también tiene una variable de entorno. En las variables de activación, `1`, `true`, `yes` y `on` activan la función.

### Streaming por WebSocket

```bash theme={null}
./raptor --enable-websocket      # or ENABLE_WEBSOCKET=true
```

Los clientes se conectan a `ws://your-server:8080/stream` para recibir cotizaciones en vivo, o a `/stream/swap` para recibir cotizaciones con una transacción lista para firmar. Raptor envía una actualización cada vez que cambia la mejor ruta, así que los clientes no necesitan hacer polling. Consulta [WebSocket](https://docs.solanatracker.io/es/raptor/overview.md#websocket) para ver el formato de los mensajes.

### Enviar y seguir transacciones

```bash theme={null}
./raptor --enable-yellowstone-jet      # or ENABLE_YELLOWSTONE_JET=true
```

Esto activa `POST /send-transaction` y `GET /transaction/{signature}`. Raptor envía las transacciones firmadas directamente a los próximos líderes de bloque por QUIC mediante [Yellowstone Jet](https://github.com/rpcpool/yellowstone-jet) y las reenvía hasta que se ejecutan o expiran. Consulta [Enviar y seguir transacciones](https://docs.solanatracker.io/es/raptor/transactions.md) para ver los formatos de solicitud y respuesta.

| Flag | Variable | Por defecto | Qué hace |
| - | - | - | - |
| `--jet-identity <PATH>` | `JET_IDENTITY` | ninguno | Archivo de keypair desde el que enviar. Una identidad de validador con stake obtiene prioridad ponderada por stake con los líderes. |
| `--jet-identities <N>` | `JET_NUM_IDENTITIES` | `4` | Sin `--jet-identity`, Raptor envía desde este número de identidades aleatorias. |
| `--tx-cache-ttl <SECS>` | `TX_CACHE_TTL_SECS` | `30` | Cuánto tiempo se puede consultar el estado de una transacción finalizada |
| `--tx-pending-expiry <SECS>` | `TX_PENDING_EXPIRY_SECS` | `120` | Cuándo se marca como `expired` una transacción que no se ha ejecutado |

El servidor necesita acceso UDP saliente a los validadores de Solana para QUIC.

### Cotizar y hacer swap en una sola llamada

```bash theme={null}
./raptor --enable-quote-and-swap      # or -s, or ENABLE_QUOTE_AND_SWAP=true
```

Esto activa `POST /quote-and-swap`, que cotiza y construye la transacción en una sola solicitud. Ahorra un viaje de ida y vuelta a los bots y backends que no necesitan mostrar antes la cotización. Consulta [Cotización y swap en una sola solicitud](https://docs.solanatracker.io/es/raptor/http/quote-and-swap-in-one-request.md).

### Arbitraje

```bash theme={null}
./raptor --enable-arbitrage      # or ENABLE_ARBITRAGE=true
```

Esto permite que `/quote` acepte el mismo mint como entrada y salida, por ejemplo SOL a SOL. Raptor busca entonces un ciclo a través de varios pools que devuelva más de lo que pusiste, como se describe en [Arbitraje](https://docs.solanatracker.io/es/raptor/overview.md#arbitrage).

Sin este flag, las cotizaciones con el mismo mint devuelven `400` con `Circular arbitrage is disabled`.

## Limita lo que enruta Raptor

Por defecto, Raptor enruta por todos los DEX y pools soportados. Estos filtros lo limitan para toda la instancia. Los filtros de DEX también reducen lo que Raptor recibe de Yellowstone, lo que ahorra memoria y ancho de banda. Quien llama a la API puede limitar más el routing en cada solicitud con [`dexes` y `pools`](https://docs.solanatracker.io/es/raptor/overview#limit-the-route).

| Flag | Variable | Qué hace |
| - | - | - |
| `--include-dexes <DEXES>` | `INCLUDE_DEXES` | Usa solo estos DEX, separados por comas |
| `--exclude-dexes <DEXES>` | `EXCLUDE_DEXES` | Usa todos los DEX excepto estos, separados por comas |
| `--include-mints-file <PATH>` | `INCLUDE_MINTS_FILE` | Usa solo pools que tengan al menos un mint de este archivo |
| `--include-pools-file <PATH>` | `INCLUDE_POOLS_FILE` | Usa solo los pools listados en este archivo |

Los nombres de DEX no distinguen mayúsculas de minúsculas y admiten varias grafías, así que `raydium-clmm`, `raydium_clmm` y `"Raydium CLMM"` se refieren al mismo DEX. `raydium` y `meteora` coinciden con todos los tipos de pool de ese DEX, y `orca` coincide con Whirlpool. Define una lista de inclusión o una de exclusión, no ambas. Si defines las dos, gana la de inclusión.

```bash theme={null}
./raptor --include-dexes raydium,meteora,whirlpool,pumpswap
```

Los archivos de allowlist tienen una dirección por línea. Raptor ignora las líneas vacías, y `#` inicia un comentario. Si combinas filtros, un pool debe pasarlos todos.

```text theme={null}
# mints.txt
So11111111111111111111111111111111111111112
EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
```

```bash theme={null}
./raptor --include-mints-file mints.txt
```

## Ejecuta varias instancias

Cada instancia funciona de forma independiente con su propio stream de Yellowstone, así que puedes poner todas las que necesites detrás de un balanceador de carga.

Cada cotización lleva un `quoteId` firmado. Por defecto, `/swap` solo acepta cotizaciones creadas por la misma instancia. Si tu balanceador de carga puede enviar el `/quote` y el `/swap` de un cliente a instancias distintas, configura el mismo secreto en todas:

```bash theme={null}
export RAPTOR_QUOTE_SECRET="a-random-string-of-at-least-32-characters"
```

Las instancias que comparten el secreto aceptan las cotizaciones de las demás. Genera uno con `openssl rand -hex 32` y mantenlo en privado.

## Memoria y rendimiento

| Flag | Variable | Por defecto | Qué hace |
| - | - | - | - |
| `--workers <N>` | `WORKER_THREADS` | Núcleos de CPU | Hilos de trabajo |
| `--low-memory` | `LOW_MEMORY_MODE` | desactivado | Usa cachés acotadas y guarda los pools de bonding curve en disco en lugar de en memoria |
| `--memory-limit <MB>` | `MEMORY_LIMIT_MB` | 80% de la RAM del sistema | Presupuesto de memoria para el modo de poca memoria |
| `--rpc-rate-limit <N>` | `RPC_RATE_LIMIT` | sin límite | Máximo de solicitudes RPC por segundo, para no superar el límite de tu proveedor |
| | `RAPTOR_POOL_DATA_DIR` | `.r_cache` junto al binario | Directorio de la caché de pools en disco |

Usa `--low-memory` en servidores pequeños. Launchpads como Pump.fun tienen millones de pools de bonding curve, y el modo de poca memoria los mantiene en disco.

### Opciones de arranque

| Flag | Variable | Qué hace |
| - | - | - |
| `--skip-pool-indexer-wait` | `SKIP_POOL_INDEXER_WAIT` | Empieza a servir antes de que se sincronice el índice de pools. Las primeras cotizaciones pueden omitir pools. |
| `--no-pool-indexer` | `NO_POOL_INDEXER` | No descarga el índice de pools desde Solana Tracker. Raptor encuentra los pools solo con Yellowstone, lo que tarda mucho más en cubrirlos todos. |

## Ejecútalo como servicio

> [tab] systemd
>
> Pon `raptor` y `raptor.sig` en `/opt/raptor` y luego crea `/etc/systemd/system/raptor.service`:
>
> ```ini theme={null}
> [Unit]
> Description=Raptor swap API
> After=network-online.target
> Wants=network-online.target
>
> [Service]
> WorkingDirectory=/opt/raptor
> ExecStart=/opt/raptor/raptor --enable-websocket --enable-yellowstone-jet
> EnvironmentFile=/opt/raptor/raptor.env
> Restart=always
> RestartSec=5
> LimitNOFILE=1048576
>
> [Install]
> WantedBy=multi-user.target
> ```
>
> Pon tu configuración en `/opt/raptor/raptor.env`, con un `NAME=value` por línea:
>
> ```bash theme={null}
> RPC_URL=https://your-rpc.example.com
> YELLOWSTONE_ENDPOINT=https://your-grpc.example.com
> YELLOWSTONE_TOKEN=your-token
> RAPTOR_QUOTE_SECRET=your-shared-secret
> ```
>
> Inícialo y sigue los logs:
>
> ```bash theme={null}
> sudo systemctl daemon-reload
> sudo systemctl enable --now raptor
> journalctl -u raptor -f
> ```

> [tab] Docker
>
> Descomprime la versión de Linux junto a este `Dockerfile`:
>
> ```dockerfile theme={null}
> FROM debian:bookworm-slim
> RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
>     && rm -rf /var/lib/apt/lists/*
> WORKDIR /opt/raptor
> COPY raptor raptor.sig ./
> ENV RAPTOR_POOL_DATA_DIR=/data
> VOLUME /data
> EXPOSE 8080
> ENTRYPOINT ["/opt/raptor/raptor"]
> ```
>
> ```bash theme={null}
> docker build -t raptor .
> docker run -d --name raptor -p 8080:8080 -v raptor-data:/data \
>   -e RPC_URL=https://your-rpc.example.com \
>   -e YELLOWSTONE_ENDPOINT=https://your-grpc.example.com \
>   -e YELLOWSTONE_TOKEN=your-token \
>   raptor --enable-websocket --enable-yellowstone-jet
> ```
>
> El volumen conserva la caché de pools cuando se reemplaza el contenedor. Si tu red de Docker bloquea el UDP saliente, ejecútalo con `--network host` para que `--enable-yellowstone-jet` pueda llegar a los validadores.

## Actualización

Descarga la nueva versión de la misma forma, reemplaza `raptor` y `raptor.sig`, y reinicia. Conserva el directorio de la caché de pools entre versiones. Las notas de la versión están en [GitHub](https://github.com/solanatracker/raptor-binary/releases) y en [Cambios recientes](https://docs.solanatracker.io/es/raptor/recent-changes.md).

Para actualizar varias instancias sin tiempo de inactividad, configura en todas el mismo `RAPTOR_QUOTE_SECRET` y reinícialas de una en una. Cada instancia vuelve al balanceador de carga en cuanto `/ready` devuelve `200`.

## Referencia de configuración

Los flags aceptan su valor de las dos formas: `--workers 8` o `--workers=8`.

| Flag | Variable | Por defecto | Descripción |
| - | - | - | - |
| | `RPC_URL` | obligatorio | Endpoint RPC de Solana |
| | `YELLOWSTONE_ENDPOINT` | obligatorio | Endpoint gRPC de Yellowstone |
| | `YELLOWSTONE_TOKEN` | ninguno | Token de autenticación de Yellowstone |
| | `BIND_ADDR` | `0.0.0.0:8080` | Dirección y puerto de escucha |
| | `RAPTOR_QUOTE_SECRET` | ninguno | Secreto compartido de al menos 32 caracteres, para que las instancias acepten las cotizaciones de las demás |
| | `RAPTOR_POOL_DATA_DIR` | `.r_cache` junto al binario | Directorio de la caché de pools |
| `--enable-websocket` | `ENABLE_WEBSOCKET` | desactivado | Sirve `/stream` y `/stream/swap` |
| `--enable-yellowstone-jet` | `ENABLE_YELLOWSTONE_JET` | desactivado | Sirve `/send-transaction` y `/transaction/{signature}` |
| `-s`, `--enable-quote-and-swap` | `ENABLE_QUOTE_AND_SWAP` | desactivado | Sirve `/quote-and-swap` |
| `--enable-arbitrage` | `ENABLE_ARBITRAGE` | desactivado | Permite cotizaciones de arbitraje con el mismo mint |
| `--include-dexes <DEXES>` | `INCLUDE_DEXES` | todos | Usa solo estos DEX |
| `--exclude-dexes <DEXES>` | `EXCLUDE_DEXES` | ninguno | Nunca usa estos DEX |
| `--include-mints-file <PATH>` | `INCLUDE_MINTS_FILE` | ninguno | Usa solo pools que tengan un mint de la lista |
| `--include-pools-file <PATH>` | `INCLUDE_POOLS_FILE` | ninguno | Usa solo los pools de la lista |
| `--jet-identity <PATH>` | `JET_IDENTITY` | ninguno | Keypair desde el que enviar transacciones |
| `--jet-identities <N>` | `JET_NUM_IDENTITIES` | `4` | Identidades aleatorias de envío cuando no se configura un keypair |
| `--tx-cache-ttl <SECS>` | `TX_CACHE_TTL_SECS` | `30` | Cuánto tiempo se pueden consultar las transacciones enviadas |
| `--tx-pending-expiry <SECS>` | `TX_PENDING_EXPIRY_SECS` | `120` | Cuándo se marca como `expired` una transacción pendiente |
| `--workers <N>` | `WORKER_THREADS` | Núcleos de CPU | Hilos de trabajo |
| `--low-memory` | `LOW_MEMORY_MODE` | desactivado | Cachés acotadas y pools de bonding curve en disco |
| `--memory-limit <MB>` | `MEMORY_LIMIT_MB` | 80% de la RAM | Presupuesto de memoria para el modo de poca memoria |
| `--rpc-rate-limit <N>` | `RPC_RATE_LIMIT` | sin límite | Máximo de solicitudes RPC por segundo |
| `--skip-pool-indexer-wait` | `SKIP_POOL_INDEXER_WAIT` | desactivado | Sirve antes de que se sincronice el índice de pools |
| `--no-pool-indexer` | `NO_POOL_INDEXER` | desactivado | Encuentra pools solo con Yellowstone |
| `-h`, `--help` | | | Muestra la ayuda |
| `-v`, `--version` | | | Muestra la versión |

## Solución de problemas

> [accordion] Raptor se cierra con “RPC\_URL environment variable is required”
>
> Define `RPC_URL` y `YELLOWSTONE_ENDPOINT` en el entorno donde se ejecuta Raptor. Con systemd, ponlos en el `EnvironmentFile`, porque las variables exportadas en tu shell no llegan al servicio.

> [accordion] /quote devuelve 503 “Server warming up”
>
> Raptor sigue indexando pools. Espera a que `/ready` devuelva `200`. Si nunca lo hace, revisa los logs en busca de errores de conexión con Yellowstone y comprueba que el servidor pueda hacer solicitudes HTTPS salientes.

> [accordion] /stream, /send-transaction o /quote-and-swap devuelve 404
>
> La función está desactivada. Inicia Raptor con `--enable-websocket`, `--enable-yellowstone-jet` o `--enable-quote-and-swap`.

> [accordion] /swap rechaza una cotización creada por otra instancia
>
> Define el mismo `RAPTOR_QUOTE_SECRET` en todas las instancias o envía el `/quote` y el `/swap` de cada cliente a la misma instancia.

> [accordion] Linux indica “GLIBC\_2.30 not found”
>
> El binario necesita glibc 2.30 o posterior. Usa Ubuntu 20.04+, Debian 11+ o una distribución más reciente, o ejecuta la imagen de Docker de arriba.

> [accordion] Mi proveedor de RPC limita la tasa de Raptor
>
> Define `--rpc-rate-limit` por debajo de las solicitudes por segundo de tu plan. Raptor hace la mayoría de sus llamadas RPC al arrancar y luego lee principalmente de Yellowstone.

## Preguntas frecuentes

> [accordion] ¿El binario necesita una API key o una licencia?
>
> No. El binario es gratis por ahora: descárgalo y ejecútalo. No hay clave ni límite de solicitudes.

> [accordion] ¿Puedo revender el acceso a mi instancia?
>
> Sí. Puedes ejecutarlo detrás de tu propia API, cobrar por el acceso y añadir tu propia platform fee con `feeAccount` y `feeBps`.

> [accordion] ¿Es una alternativa al binario de Metis?
>
> Sí. Raptor cumple la misma función: un agregador autoalojado que cotiza y construye swaps. No necesita clave de binario y puedes ejecutar instancias ilimitadas.

> [accordion] ¿El código fuente está disponible?
>
> No. Raptor es de código cerrado, y el [repositorio de GitHub](https://github.com/solanatracker/raptor-binary) aloja las versiones. Abre un issue allí para bugs y solicitudes de funciones.

> [accordion] ¿Los swaps de mi instancia usan el mismo programa on-chain?
>
> Sí. Todas las instancias construyen transacciones para el programa Raptor, `RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87`.


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