Self-host Raptor

Raptor is also a single binary that you run on your own servers. It’s the same routing engine and the same HTTP and WebSocket API as the hosted service at raptor.solanatracker.io.

Currently free. There’s no charge for the binary, and no API key or license key. Download it and run it.
No limits. Run as many instances as you want and serve as many requests as your hardware handles.
You can resell it. Put your own API in front of it, charge for access or add your own platform fee.

Download from GitHub

The latest release for Linux and macOS, with checksums and release notes.

Report an issue

Bugs and feature requests go to the GitHub repository. Questions go to Discord.

You don’t need to self-host to use Raptor. The hosted API, which is also currently free, needs no setup. Self-host when you want your own capacity, your own infrastructure or no dependency on a shared service.

What the binary does

Out of the box, the binary serves quotes and builds swap transactions. Four more features are off until you turn them on.

Feature	Endpoints	Default	Turn it on with
Quotes across every supported DEX, with multi-hop, split and JIT routing	`GET /quote`	On
Build swap transactions, with priority fees, tips and platform fees	`POST /swap`, `POST /swap-instructions`	On
Health and readiness checks	`GET /health`, `GET /ready`	On
Live quote streaming	`/stream`, `/stream/swap`	Off	`--enable-websocket`
Send and track transactions	`POST /send-transaction`, `GET /transaction/{signature}`	Off	`--enable-yellowstone-jet`
Quote and build in one call	`POST /quote-and-swap`	Off	`--enable-quote-and-swap`
Arbitrage quotes, where the input and output mint are the same	`GET /quote`	Off	`--enable-arbitrage`

A request to an endpoint that’s turned off returns 404. Raptor keeps pool state current by streaming account updates from Yellowstone gRPC, so it uses very little RPC after startup.

Requirements

A Linux or macOS server.
- Linux: x86-64 with glibc 2.30 or newer, such as Ubuntu 20.04+, Debian 11+ or RHEL 9+.
- macOS: Apple Silicon or Intel.
A Solana RPC endpoint, set as RPC_URL.
A Yellowstone gRPC endpoint, set as YELLOWSTONE_ENDPOINT, plus YELLOWSTONE_TOKEN if your provider needs one. Raptor won’t start without it.
A writable directory for the pool cache. By default it’s .r_cache next to the binary. Set RAPTOR_POOL_DATA_DIR to use another directory.
Outbound HTTPS. On startup, Raptor downloads the current pool index from Solana Tracker, then keeps it current from Yellowstone.

Install

Pick the file for your server

Each release has one zip per platform, named raptor-<version>-<platform>.zip.

Server	Platform in the file name
Linux, x86-64	`x86_64-unknown-linux-gnu`
macOS, Apple Silicon	`aarch64-apple-darwin`
macOS, Intel	`x86_64-apple-darwin`

Download and verify it

These commands download the latest release and check it against the published checksums.txt.

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"

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"

The check prints raptor-<version>-<platform>.zip: OK. If it prints anything else, delete the zip and download it again.Keep raptor.sig in the same directory as raptor. The binary uses it to check that it hasn’t been modified.

Check that it runs

./raptor --version

If macOS blocks a binary you downloaded in a browser, clear the quarantine flag with xattr -d com.apple.quarantine raptor.

Run

Set your endpoints and start the server.

export RPC_URL="https://your-rpc.example.com"
export YELLOWSTONE_ENDPOINT="https://your-grpc.example.com"
export YELLOWSTONE_TOKEN="your-token"

./raptor

Raptor listens on 0.0.0.0:8080. Set BIND_ADDR to change it, for example BIND_ADDR=127.0.0.1:9000. To turn on every optional feature except arbitrage:

./raptor --enable-websocket --enable-yellowstone-jet --enable-quote-and-swap

Wait until it’s ready

Raptor indexes pools before it can route. Until it finishes, /quote returns 503 with Server warming up. /ready returns 200 once Raptor can serve quotes, and 503 before that:

curl http://localhost:8080/ready

{ "ready": true, "pool_count": 812345, "indexed_count": 812345, "indexing_in_progress": false }

/health returns OK as soon as the server is up, even while it’s still indexing. Point load-balancer health checks at /ready so an instance gets traffic only once it can quote.

Make your first quote

curl "http://localhost:8080/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50"

Every example in the overview works against your instance once you replace https://raptor.solanatracker.io with your server’s address.

Optional features

Every flag also has an environment variable. For on/off variables, 1, true, yes and on all turn the feature on.

WebSocket streaming

./raptor --enable-websocket      # or ENABLE_WEBSOCKET=true

Clients connect to ws://your-server:8080/stream for live quotes, or to /stream/swap for quotes with a ready-to-sign transaction. Raptor pushes an update whenever the best route changes, so clients don’t need to poll. See WebSocket for the message format.

Send and track transactions

./raptor --enable-yellowstone-jet      # or ENABLE_YELLOWSTONE_JET=true

This turns on POST /send-transaction and GET /transaction/{signature}. Raptor sends signed transactions straight to the upcoming block leaders over QUIC using Yellowstone Jet, and resends them until they land or expire. See Send and track transactions for the request and response formats.

Flag	Variable	Default	What it does
`--jet-identity <PATH>`	`JET_IDENTITY`	none	Keypair file to send from. A staked validator identity gets stake-weighted priority with leaders.
`--jet-identities <N>`	`JET_NUM_IDENTITIES`	`4`	Without `--jet-identity`, Raptor sends from this many random identities.
`--tx-cache-ttl <SECS>`	`TX_CACHE_TTL_SECS`	`30`	How long a finished transaction’s status stays queryable
`--tx-pending-expiry <SECS>`	`TX_PENDING_EXPIRY_SECS`	`120`	When a transaction that hasn’t landed is marked `expired`

The server needs outbound UDP access to Solana validators for QUIC.

Quote and swap in one call

./raptor --enable-quote-and-swap      # or -s, or ENABLE_QUOTE_AND_SWAP=true

This turns on POST /quote-and-swap, which quotes and builds the transaction in one request. It saves a round trip for bots and backends that don’t need to show the quote first. See Quote and swap in one request.

Arbitrage

./raptor --enable-arbitrage      # or ENABLE_ARBITRAGE=true

This lets /quote accept the same mint as input and output, for example SOL to SOL. Raptor then looks for a cycle through several pools that returns more than you put in, as described in Arbitrage. Without this flag, same-mint quotes return 400 with Circular arbitrage is disabled.

Limit what Raptor routes

By default, Raptor routes through every supported DEX and pool. These filters narrow that for the whole instance. DEX filters also reduce what Raptor streams from Yellowstone, which saves memory and bandwidth. Callers can narrow routing further on each request with dexes and pools.

Flag	Variable	What it does
`--include-dexes <DEXES>`	`INCLUDE_DEXES`	Use only these DEXes, comma-separated
`--exclude-dexes <DEXES>`	`EXCLUDE_DEXES`	Use every DEX except these, comma-separated
`--include-mints-file <PATH>`	`INCLUDE_MINTS_FILE`	Use only pools that hold at least one mint from this file
`--include-pools-file <PATH>`	`INCLUDE_POOLS_FILE`	Use only the pools listed in this file

DEX names are case-insensitive and accept several spellings, so raydium-clmm, raydium_clmm and "Raydium CLMM" all mean the same DEX. raydium and meteora match every pool type from that DEX, and orca matches Whirlpool. Set an include list or an exclude list, not both. If both are set, the include list wins.

./raptor --include-dexes raydium,meteora,whirlpool,pumpswap

Allowlist files have one address per line. Raptor ignores empty lines, and # starts a comment. When you combine filters, a pool must pass all of them.

# mints.txt
So11111111111111111111111111111111111111112
EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

./raptor --include-mints-file mints.txt

Run several instances

Each instance runs independently with its own Yellowstone stream, so you can put as many as you need behind a load balancer. Every quote carries a signed quoteId. By default, /swap accepts only quotes made by the same instance. If your load balancer can send a client’s /quote and /swap to different instances, give every instance the same secret:

export RAPTOR_QUOTE_SECRET="a-random-string-of-at-least-32-characters"

Instances that share the secret accept each other’s quotes. Generate one with openssl rand -hex 32 and keep it private.

Memory and performance

Flag	Variable	Default	What it does
`--workers <N>`	`WORKER_THREADS`	CPU cores	Worker threads
`--low-memory`	`LOW_MEMORY_MODE`	off	Use bounded caches and keep bonding-curve pools on disk instead of in memory
`--memory-limit <MB>`	`MEMORY_LIMIT_MB`	80% of system RAM	Memory budget for low-memory mode
`--rpc-rate-limit <N>`	`RPC_RATE_LIMIT`	unlimited	Most RPC requests per second, to stay under your provider’s limit
	`RAPTOR_POOL_DATA_DIR`	`.r_cache` beside the binary	Directory for the on-disk pool cache

Use --low-memory on small servers. Launchpads such as Pump.fun have millions of bonding-curve pools, and low-memory mode keeps them on disk.

Startup options

Flag	Variable	What it does
`--skip-pool-indexer-wait`	`SKIP_POOL_INDEXER_WAIT`	Start serving before the pool index has synced. Early quotes may miss pools.
`--no-pool-indexer`	`NO_POOL_INDEXER`	Don’t download the pool index from Solana Tracker. Raptor finds pools from Yellowstone alone, which takes much longer to cover every pool.

Run it as a service

systemd
Docker

Put raptor and raptor.sig in /opt/raptor, then create /etc/systemd/system/raptor.service:

[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

Put your settings in /opt/raptor/raptor.env, one NAME=value per line:

RPC_URL=https://your-rpc.example.com
YELLOWSTONE_ENDPOINT=https://your-grpc.example.com
YELLOWSTONE_TOKEN=your-token
RAPTOR_QUOTE_SECRET=your-shared-secret

Start it and follow the logs:

sudo systemctl daemon-reload
sudo systemctl enable --now raptor
journalctl -u raptor -f

Unzip the Linux release next to this Dockerfile:

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"]

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

The volume keeps the pool cache when the container is replaced. If your Docker network blocks outbound UDP, run with --network host so --enable-yellowstone-jet can reach validators.

Update

Download the new release the same way, replace raptor and raptor.sig, and restart. Keep the pool cache directory between versions. Release notes are on GitHub and in Recent changes. To update several instances without downtime, give them all the same RAPTOR_QUOTE_SECRET and restart them one at a time. Each instance rejoins the load balancer once /ready returns 200.

Configuration reference

Flags take their value either way: --workers 8 or --workers=8.

Flag	Variable	Default	Description
	`RPC_URL`	required	Solana RPC endpoint
	`YELLOWSTONE_ENDPOINT`	required	Yellowstone gRPC endpoint
	`YELLOWSTONE_TOKEN`	none	Yellowstone auth token
	`BIND_ADDR`	`0.0.0.0:8080`	Address and port to listen on
	`RAPTOR_QUOTE_SECRET`	none	Shared secret of at least 32 characters, so instances accept each other’s quotes
	`RAPTOR_POOL_DATA_DIR`	`.r_cache` beside the binary	Pool cache directory
`--enable-websocket`	`ENABLE_WEBSOCKET`	off	Serve `/stream` and `/stream/swap`
`--enable-yellowstone-jet`	`ENABLE_YELLOWSTONE_JET`	off	Serve `/send-transaction` and `/transaction/{signature}`
`-s`, `--enable-quote-and-swap`	`ENABLE_QUOTE_AND_SWAP`	off	Serve `/quote-and-swap`
`--enable-arbitrage`	`ENABLE_ARBITRAGE`	off	Allow same-mint arbitrage quotes
`--include-dexes <DEXES>`	`INCLUDE_DEXES`	all	Use only these DEXes
`--exclude-dexes <DEXES>`	`EXCLUDE_DEXES`	none	Never use these DEXes
`--include-mints-file <PATH>`	`INCLUDE_MINTS_FILE`	none	Use only pools holding a listed mint
`--include-pools-file <PATH>`	`INCLUDE_POOLS_FILE`	none	Use only the listed pools
`--jet-identity <PATH>`	`JET_IDENTITY`	none	Keypair to send transactions from
`--jet-identities <N>`	`JET_NUM_IDENTITIES`	`4`	Random sending identities when no keypair is set
`--tx-cache-ttl <SECS>`	`TX_CACHE_TTL_SECS`	`30`	How long sent transactions stay queryable
`--tx-pending-expiry <SECS>`	`TX_PENDING_EXPIRY_SECS`	`120`	When a pending transaction is marked `expired`
`--workers <N>`	`WORKER_THREADS`	CPU cores	Worker threads
`--low-memory`	`LOW_MEMORY_MODE`	off	Bounded caches and on-disk bonding-curve pools
`--memory-limit <MB>`	`MEMORY_LIMIT_MB`	80% of RAM	Memory budget for low-memory mode
`--rpc-rate-limit <N>`	`RPC_RATE_LIMIT`	unlimited	Most RPC requests per second
`--skip-pool-indexer-wait`	`SKIP_POOL_INDEXER_WAIT`	off	Serve before the pool index has synced
`--no-pool-indexer`	`NO_POOL_INDEXER`	off	Find pools from Yellowstone only
`-h`, `--help`			Show help
`-v`, `--version`			Show the version

Troubleshooting

Raptor exits with “RPC_URL environment variable is required”

Set RPC_URL and YELLOWSTONE_ENDPOINT in the environment that runs Raptor. Under systemd, put them in the EnvironmentFile, because variables exported in your shell don’t reach the service.

/quote returns 503 “Server warming up”

Raptor is still indexing pools. Wait until /ready returns 200. If it never does, check the logs for Yellowstone connection errors, and check that the server can make outbound HTTPS requests.

/stream, /send-transaction or /quote-and-swap returns 404

The feature is turned off. Start Raptor with --enable-websocket, --enable-yellowstone-jet or --enable-quote-and-swap.

/swap rejects a quote made by another instance

Set the same RAPTOR_QUOTE_SECRET on every instance, or send each client’s /quote and /swap to the same instance.

Linux reports “GLIBC_2.30 not found”

The binary needs glibc 2.30 or newer. Use Ubuntu 20.04+, Debian 11+ or a newer distribution, or run the Docker image above.

My RPC provider rate-limits Raptor

Set --rpc-rate-limit below your plan’s requests per second. Raptor makes most of its RPC calls at startup, then reads mainly from Yellowstone.

FAQ

Does the binary need an API key or a license?

No. The binary is currently free: download it and run it. There’s no key and no request limit.

Can I resell access to my instance?

Yes. You can run it behind your own API, charge for access and add your own platform fee with feeAccount and feeBps.

Is it an alternative to the Metis binary?

Yes. Raptor fills the same role: a self-hosted aggregator that quotes and builds swaps. It needs no binary key, and you can run unlimited instances.

Is the source code available?

No. Raptor is closed source, and the GitHub repository hosts the releases. Open an issue there for bugs and feature requests.

Do swaps from my instance use the same on-chain program?

Yes. Every instance builds transactions for the Raptor program, RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87.

Getting Started

Recent changes

API Reference

WebSocket

Resources

Download from GitHub

Report an issue

What the binary does

Requirements

Install

Run

Wait until it’s ready

Make your first quote

Optional features

WebSocket streaming

Send and track transactions

Quote and swap in one call

Arbitrage

Limit what Raptor routes

Run several instances

Memory and performance

Startup options

Run it as a service

Update

Configuration reference

Troubleshooting

FAQ

Download from GitHub

Report an issue

​What the binary does

​Requirements

​Install

​Run

​Wait until it’s ready

​Make your first quote

​Optional features

​WebSocket streaming

​Send and track transactions

​Quote and swap in one call

​Arbitrage

​Limit what Raptor routes

​Run several instances

​Memory and performance

​Startup options

​Run it as a service

​Update

​Configuration reference

​Troubleshooting

​FAQ

What the binary does

Requirements

Install

Run

Wait until it’s ready

Make your first quote

Optional features

WebSocket streaming

Send and track transactions

Quote and swap in one call

Arbitrage

Limit what Raptor routes

Run several instances

Memory and performance

Startup options

Run it as a service

Update

Configuration reference

Troubleshooting

FAQ