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

# Self-host Raptor

> Download the free Raptor binary from GitHub and run the same swap API on your own servers. No API key, no request limits and as many instances as you like.

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>;
};

Raptor is also a single binary that you run on your own servers. It's the same routing engine and the same [HTTP](/raptor/http/get-swap-quote) and [WebSocket](#websocket-streaming) 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](/raptor/overview#platform-fees).

<CardGroup cols={2}>
  <Card title="Download from GitHub" icon="https://mintcdn.com/solanatracker/l0aXlX5jJ7xpUiwY/icons/hugeicons/github.svg?fit=max&auto=format&n=l0aXlX5jJ7xpUiwY&q=85&s=759067114bc56976257e54ca8853a9cc" iconType="duotone" href="https://github.com/solanatracker/raptor-binary/releases/latest" width="24" height="24" data-path="icons/hugeicons/github.svg">
    The latest release for Linux and macOS, with checksums and release notes.
  </Card>

  <Card title="Report an issue" icon="https://mintcdn.com/solanatracker/l0aXlX5jJ7xpUiwY/icons/hugeicons/code.svg?fit=max&auto=format&n=l0aXlX5jJ7xpUiwY&q=85&s=b91d6ca3fc1cb69e901a01980d2e917d" iconType="duotone" href="https://github.com/solanatracker/raptor-binary/issues" width="24" height="24" data-path="icons/hugeicons/code.svg">
    Bugs and feature requests go to the GitHub repository. Questions go to Discord.
  </Card>
</CardGroup>

<Info>
  You don't need to self-host to use Raptor. The [hosted API](/raptor/overview), 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.
</Info>

## 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](/raptor/overview#supported-dexs), with multi-hop, split and [JIT](/raptor/overview#jit-routing) 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](#websocket-streaming) | `/stream`, `/stream/swap` | Off | `--enable-websocket` |
| [Send and track transactions](#send-and-track-transactions) | `POST /send-transaction`, `GET /transaction/{signature}` | Off | `--enable-yellowstone-jet` |
| [Quote and build in one call](#quote-and-swap-in-one-call) | `POST /quote-and-swap` | Off | `--enable-quote-and-swap` |
| [Arbitrage quotes](/raptor/overview#arbitrage), 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.

<SelfHostDiagram />

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

<Steps>
  <Step title="Pick the file for your server">
    Each [release](https://github.com/solanatracker/raptor-binary/releases/latest) 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` |
  </Step>

  <Step title="Download and verify it">
    These commands download the latest release and check it against the published `checksums.txt`.

    <CodeGroup>
      ```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"
      ```
    </CodeGroup>

    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.
  </Step>

  <Step title="Check that it runs">
    ```bash theme={null}
    ./raptor --version
    ```

    If macOS blocks a binary you downloaded in a browser, clear the quarantine flag with `xattr -d com.apple.quarantine raptor`.
  </Step>
</Steps>

## Run

Set your endpoints and start the server.

```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 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:

```bash theme={null}
./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:

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

```json theme={null}
{ "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

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

Every example in the [overview](/raptor/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

```bash theme={null}
./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](/raptor/overview#websocket) for the message format.

### Send and track transactions

```bash theme={null}
./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](https://github.com/rpcpool/yellowstone-jet), and resends them until they land or expire. See [Send and track transactions](/raptor/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

```bash theme={null}
./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](/raptor/http/quote-and-swap-in-one-request).

### Arbitrage

```bash theme={null}
./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](/raptor/overview#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`](/raptor/overview#limit-the-route).

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

```bash theme={null}
./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.

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

```bash theme={null}
./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:

```bash theme={null}
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

<Tabs>
  <Tab title="systemd">
    Put `raptor` and `raptor.sig` in `/opt/raptor`, then create `/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
    ```

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

    ```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
    ```

    Start it and follow the logs:

    ```bash theme={null}
    sudo systemctl daemon-reload
    sudo systemctl enable --now raptor
    journalctl -u raptor -f
    ```
  </Tab>

  <Tab title="Docker">
    Unzip the Linux release next to this `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
    ```

    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.
  </Tab>
</Tabs>

## 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](https://github.com/solanatracker/raptor-binary/releases) and in [Recent changes](/raptor/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

<AccordionGroup>
  <Accordion title="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.
  </Accordion>

  <Accordion title="/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.
  </Accordion>

  <Accordion title="/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`.
  </Accordion>

  <Accordion title="/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.
  </Accordion>

  <Accordion title="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.
  </Accordion>

  <Accordion title="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.
  </Accordion>
</AccordionGroup>

## FAQ

<AccordionGroup>
  <Accordion title="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.
  </Accordion>

  <Accordion title="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`.
  </Accordion>

  <Accordion title="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.
  </Accordion>

  <Accordion title="Is the source code available?">
    No. Raptor is closed source, and the [GitHub repository](https://github.com/solanatracker/raptor-binary) hosts the releases. Open an issue there for bugs and feature requests.
  </Accordion>

  <Accordion title="Do swaps from my instance use the same on-chain program?">
    Yes. Every instance builds transactions for the Raptor program, `RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87`.
  </Accordion>
</AccordionGroup>


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