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

# EVM quote

> The best exact-in route for `amount` of `inputMint` into `outputMint` on one EVM chain,
priced by the venues' own contracts (V2 router `getAmountsOut`, V3 QuoterV2
`quoteExactInput`), all at one block: `contextSlot` is its number, `blockHash` its hash.
The response is a Jupiter-shaped quote, like the Solana router's: pass it unchanged as
`quoteResponse` to `POST /evm/swap` before `expiresAt` (15 seconds after quoting; 30 on
`eth`). Quotes are kept in the router's memory only, and a build takes only a quote this
router made and still holds.

**Routes.** Direct, through one intermediate token (`maxHops` 2, the default) or through
two (`maxHops` 3), every hop on the same venue. Intermediates are the chain's hubs (listed
by `GET /evm/chains`) and tokens recently seen paired with the input or the output. At most
48 routes are priced (`candidates` says how many were); the most output wins, then fewer
hops, then less gas. `routePlan` has one step per hop (`percent` 100 and `bps` 10000: there
are no splits) with the pool (`ammKey`), the venue's `dex` label, the hop's amounts and, on
V3, the pool's `feeTier`. Inside a route the wrapped token stands for the native coin.
`router` is the contract the swap transaction will go to.

**Floor.** `otherAmountThreshold` is `outAmount × (10000 − slippageBps) / 10000`, rounded
down. The build writes it into the swap's calldata. A floor of zero is refused
(`422 declined amount_too_small`); an amount so small that no route gives anything is
`404 declined no_route`.

**Native coin.** `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` (any case) or `native` is the
chain's coin (ETH, BNB), distinct from its wrapped token; answers write it in lower case.
Native to wrapped is a wrap (`deposit()`), wrapped to native an unwrap (`withdraw`), on the
wrapped-token contract itself: one step labelled `Wrap` or `Unwrap` whose `ammKey` is the
wrapped token, 1:1, `otherAmountThreshold` equal to `inAmount` whatever the slippage, no
pool, `candidates` 0. Venue filters do not apply to them.

**Differences from the Solana `GET /quote`:** `chain` is required; mints are `0x` addresses
and amounts uint256; ExactIn only; `maxHops` at most 3; no split and no platform fee
(`platformFeeBps` above 0 is `400`, not ignored); `allowSplit`, `feeOnInput`,
`forJitoBundle`, `reserveKeys` and `asLegacyTransaction` are ignored; `priceImpactPct` is
always `"0"`; no `swapInfo.walkSteps`; extra fields `swapInfo.feeTier`, `chain`, `chainId`,
`router`, `gasEstimate`, `blockHash`, `expiresAt`, `candidates`; `quoteId` is a UUID.


Guide: [EVM swaps](/router/evm#the-quote). Pass the answer unchanged as `quoteResponse` to [`POST /evm/swap`](/api-reference/router/evm-swap) before its `expiresAt`. Errors: [EVM errors](/router/evm#errors).


## OpenAPI

````yaml router.openapi.yaml GET /evm/quote
openapi: 3.1.0
info:
  title: Raze Swap Router API
  version: 1.0.0
  description: >
    Quotes and **unsigned** transactions for swaps on Solana, routed through a
    deploy of the `swap`

    program over the venues `GET /venues` lists as `buildable` and `servable`,
    and, under `/evm`, on

    Ethereum, BNB Chain, Base and Robinhood Chain (see **EVM routes** below).
    The router **never

    signs and never sends**: you get a quote, then the instructions (or a
    serialized, unsigned

    transaction), and you sign and broadcast from your backend.


    **Public router.** `https://router.raze.bot` is Raze's router. It takes the
    same **API key** as

    the market-data API (`x-api-key`, `Authorization: Bearer` or `?apiKey=`;
    only `/health`,

    `/ready`, `/evm/health` and `/evm/ready` are open), shares the account's
    limit a

    minute with it and spends credits for each request it lets in. Its Solana
    routes have no path

    prefix (`/quote`, `/swap-instructions`, …),

    issues no `routeTicket`, and builds for Raze's deploy of the `swap` program,

    `DADMMjfNnY6z8H9h9RfHZ9tfarBySsj4Yb65qLyKJDAD`. A missing or unknown key
    answers `401` and a

    request over the limit `429`, both with the API's body,

    `{"error": {"code": "unauthorized" | "rate_limited", "message"}}`.


    **EVM routes (`/evm`).** The same host quotes and builds swaps on Ethereum
    (`eth`, chain id 1),

    BNB Chain (`bsc`, 56), Base (`base`, 8453) and Robinhood Chain (`robinhood`,
    4663), over Uniswap

    V2 and V3 (eth, base, robinhood) and PancakeSwap V2 and V3 (bsc): `GET` and
    `POST /evm/quote`,

    `POST /evm/swap` (alias `POST /evm/swap-instructions`), `GET /evm/venues`,
    `GET /evm/chains`,

    and the open `GET /evm/health` and `GET /evm/ready`. Same key, same limit a
    minute, same

    credits. They speak the Solana routes' API, so Jupiter's: the same parameter
    and field names

    (`inputMint`, `outputMint`, `amount`, `slippageBps`, `routePlan`,
    `otherAmountThreshold`,

    `quoteResponse`, `userPublicKey`, …), the conventions and the error shape
    below, `404 not_found`

    for an unknown path (`/evm/build` and `/evm/deployments` are gone) and `405`
    with `Allow` for a

    wrong method. What differs, because EVM does:

    - `chain` is required: `eth`, `bsc`, `base`, `robinhood` or the chain id
    (alias `chainId`).

    - Mints and wallets are `0x` addresses in any case (answers are lower case);
    the native coin is
      `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` (or `native`). Inside a `routePlan` the wrapped
      token stands for it.
    - Amounts are uint256 in base units: decimal strings of any size, or JSON
    integers up to
      2^64 − 1. `contextSlot` is the block number.
    - ExactIn only (`ExactOut` is `400`), `maxHops` at most 3 (default 2), one
    venue per route, no
      split, no platform fee (`platformFeeBps` or `feeBps` above 0 is `400`, not ignored).
    - The build returns unsigned transactions instead of instructions:
    `setupTransactions` (the
      approvals), then `swapTransaction`, simulated together, that you sign and send in order from
      your own RPC. It builds only a quote this router made and still holds (`quoteResponse.quoteId`),
      and a `quoteResponse` that says otherwise about it is `400 quote_mismatch`.
    - Errors carry no `quoteId`. A request is cut at 10 seconds (`503 rpc`,
    `request_timeout`).


    **One router, one `swap` deploy.** A router builds for the program address
    in its

    `ROUTER_SWAP_PROGRAM_ID` (the `programId` of every `swapInstruction` is that
    address) and

    reads that deploy's on-chain config: a venue the config has no live row for
    is never served,

    and while the config is paused every build answers `503`. A client with its
    own deploy runs

    its own router: it has no keys, no accounts and no rate limit and listens on
    loopback by

    default (`ROUTER_LISTEN`), so keep it behind your own gateway.


    **Conventions of the Solana routes:**

    - Amounts are integers in the token's base units (lamports, atoms). In
    quotes and builds the
      u64 amounts are decimal **strings** (`inAmount`, `outAmount`, `otherAmountThreshold`,
      `swapInfo.inAmount` / `outAmount`, `platformFee.amount`, every `costs.*Lamports*` field).
      `slippageBps`, `contextSlot`, `minReturn`, `maxAmountIn`, `computeUnits`,
      `loadedAccountsDataSize`, `lastValidBlockHeight` and every `transactionConfig` field are JSON
      numbers.
    - Mints and wallets are base58 addresses; wrapped SOL is
    `So11111111111111111111111111111111111111112`.

    - Venue labels (`label`, `dexes`, `excludeDexes`) are the `dex` names of
    `GET /venues`; input
      labels match case- and punctuation-insensitively, aliases included.
    - Request bodies are read as JSON whatever the `Content-Type`; at most 256
    KiB (larger is `413`).

    - Unknown fields and query parameters are ignored, not rejected.


    **Solana transactions are v1** (SIMD-0385, prefix `0x81`, up to 4,096 bytes
    and 64 account keys, no

    address lookup tables). The compute-unit limit, loaded-accounts limit and
    priority fee travel in

    the message header (`transactionConfig`), not as ComputeBudget instructions.
    Signing a v1

    transaction needs an SDK that supports it. `txVersion: 0` and
    `asLegacyTransaction: true` are

    refused.


    **Errors** of the Solana routes are `{"error", "reason", "quoteId"}`:
    `error` is a closed code, `reason` a label or a

    sentence, `quoteId` present once the request was parsed. The status says
    whose move it is:

    `400` fix the request, `404` no route exists (or an unknown path:
    `not_found`), `409` re-quote

    or retry later, `413` too large, `422` a named decline that waiting will not
    change, `500` a

    router bug, `503` not ready: retry with backoff. Two bodies differ:
    `not_ready` carries

    `reasons` (a list) instead of `reason`, and a `low_liquidity` decline adds
    `liquidity`. A known

    path with the wrong method (`GET /swap`) is `405` with an empty body and an
    `Allow` header.


    The Solana quote and swap fields mirror Jupiter's Swap API (Metis), so most
    clients change only the

    host; differences are listed on each operation.
servers:
  - url: https://router.raze.bot
    description: Raze's public router (API key)
security:
  - ApiKeyHeader: []
  - Bearer: []
  - ApiKeyQuery: []
tags:
  - name: ops
    description: Liveness and readiness
  - name: venues
    description: The venues this router knows, and the price oracle's verdict on each
  - name: swap
    description: Quote, then build the instructions or the unsigned transaction
  - name: transactions
    description: Serialize your own instructions as an unsigned v1 transaction
  - name: EVM swap
    description: >-
      Quote and build swaps on Ethereum, BNB Chain, Base and Robinhood Chain,
      under /evm
  - name: EVM catalog
    description: The EVM chains, their policy and the venue manifest
  - name: EVM ops
    description: Liveness and readiness of the EVM routes
paths:
  /evm/quote:
    get:
      tags:
        - EVM swap
      summary: Quote an EVM swap
      description: >
        The best exact-in route for `amount` of `inputMint` into `outputMint` on
        one EVM chain,

        priced by the venues' own contracts (V2 router `getAmountsOut`, V3
        QuoterV2

        `quoteExactInput`), all at one block: `contextSlot` is its number,
        `blockHash` its hash.

        The response is a Jupiter-shaped quote, like the Solana router's: pass
        it unchanged as

        `quoteResponse` to `POST /evm/swap` before `expiresAt` (15 seconds after
        quoting; 30 on

        `eth`). Quotes are kept in the router's memory only, and a build takes
        only a quote this

        router made and still holds.


        **Routes.** Direct, through one intermediate token (`maxHops` 2, the
        default) or through

        two (`maxHops` 3), every hop on the same venue. Intermediates are the
        chain's hubs (listed

        by `GET /evm/chains`) and tokens recently seen paired with the input or
        the output. At most

        48 routes are priced (`candidates` says how many were); the most output
        wins, then fewer

        hops, then less gas. `routePlan` has one step per hop (`percent` 100 and
        `bps` 10000: there

        are no splits) with the pool (`ammKey`), the venue's `dex` label, the
        hop's amounts and, on

        V3, the pool's `feeTier`. Inside a route the wrapped token stands for
        the native coin.

        `router` is the contract the swap transaction will go to.


        **Floor.** `otherAmountThreshold` is `outAmount × (10000 − slippageBps)
        / 10000`, rounded

        down. The build writes it into the swap's calldata. A floor of zero is
        refused

        (`422 declined amount_too_small`); an amount so small that no route
        gives anything is

        `404 declined no_route`.


        **Native coin.** `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` (any case)
        or `native` is the

        chain's coin (ETH, BNB), distinct from its wrapped token; answers write
        it in lower case.

        Native to wrapped is a wrap (`deposit()`), wrapped to native an unwrap
        (`withdraw`), on the

        wrapped-token contract itself: one step labelled `Wrap` or `Unwrap`
        whose `ammKey` is the

        wrapped token, 1:1, `otherAmountThreshold` equal to `inAmount` whatever
        the slippage, no

        pool, `candidates` 0. Venue filters do not apply to them.


        **Differences from the Solana `GET /quote`:** `chain` is required; mints
        are `0x` addresses

        and amounts uint256; ExactIn only; `maxHops` at most 3; no split and no
        platform fee

        (`platformFeeBps` above 0 is `400`, not ignored); `allowSplit`,
        `feeOnInput`,

        `forJitoBundle`, `reserveKeys` and `asLegacyTransaction` are ignored;
        `priceImpactPct` is

        always `"0"`; no `swapInfo.walkSteps`; extra fields `swapInfo.feeTier`,
        `chain`, `chainId`,

        `router`, `gasEstimate`, `blockHash`, `expiresAt`, `candidates`;
        `quoteId` is a UUID.
      operationId: evmGetQuote
      parameters:
        - $ref: '#/components/parameters/evmChain'
        - $ref: '#/components/parameters/evmInputMint'
        - $ref: '#/components/parameters/evmOutputMint'
        - $ref: '#/components/parameters/evmAmount'
        - $ref: '#/components/parameters/slippageBps'
        - $ref: '#/components/parameters/evmSwapMode'
        - $ref: '#/components/parameters/evmMaxHops'
        - $ref: '#/components/parameters/onlyDirectRoutes'
        - $ref: '#/components/parameters/evmDexes'
        - $ref: '#/components/parameters/evmExcludeDexes'
        - $ref: '#/components/parameters/evmPlatformFeeBps'
      responses:
        '200':
          $ref: '#/components/responses/EvmQuote'
        '400':
          $ref: '#/components/responses/EvmQuoteBadRequest'
        '401':
          $ref: '#/components/responses/EvmUnauthorized'
        '404':
          $ref: '#/components/responses/EvmNoRoute'
        '422':
          $ref: '#/components/responses/EvmQuoteDeclined'
        '429':
          $ref: '#/components/responses/EvmRateLimited'
        '503':
          $ref: '#/components/responses/EvmNotReady'
components:
  parameters:
    evmChain:
      name: chain
      in: query
      required: true
      description: >-
        `eth`, `bsc`, `base` or `robinhood` (also `ethereum`, `bnb`), or the
        chain id: `1`, `56`, `8453`, `4663`. Alias `chainId`
      schema:
        type: string
        example: base
    evmInputMint:
      name: inputMint
      in: query
      required: true
      description: >-
        Token you spend: its `0x` address (any case), or
        `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` or `native` for the chain's
        coin. The zero address is refused
      schema:
        type: string
        example: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
    evmOutputMint:
      name: outputMint
      in: query
      required: true
      description: >-
        Token you receive, spelled as `inputMint`. Must differ from it: there
        are no cycles on EVM
      schema:
        type: string
        example: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
    evmAmount:
      name: amount
      in: query
      required: true
      description: >-
        What you spend: a uint256 in the token's smallest unit (wei for the
        native coin), in decimal digits. No sign, fraction or exponent. `0` is
        `400 declined zero_amount`
      schema:
        type: string
        pattern: ^[0-9]+$
        example: '1000000000000000'
    slippageBps:
      name: slippageBps
      in: query
      description: Tolerance in basis points, 0–10000; above 10000 is `400`
      schema:
        type: integer
        minimum: 0
        maximum: 10000
        default: 50
    evmSwapMode:
      name: swapMode
      in: query
      description: 'Only `ExactIn` (or `exactIn`): `ExactOut` is `400`'
      schema:
        type: string
        enum:
          - ExactIn
          - exactIn
        default: ExactIn
    evmMaxHops:
      name: maxHops
      in: query
      description: >-
        Most hops per route: `1` direct only, `2` through at most one
        intermediate token, `3` two. `0` counts as 1; more than 3 counts as 3
      schema:
        type: integer
        minimum: 0
        default: 2
    onlyDirectRoutes:
      name: onlyDirectRoutes
      in: query
      description: '`true` is `maxHops=1`: a single pool'
      schema:
        type: boolean
        default: false
    evmDexes:
      name: dexes
      in: query
      description: >-
        Only these venues: `dex` labels (`Uniswap V3`, `PancakeSwap V2`, …) or
        venue ids (`base-uniswap-v3`) from `/evm/venues`, matched ignoring case
        and punctuation; comma-separated or the parameter repeated. Alias
        `includeDex`. Unknown labels next to known ones are ignored; only
        unknown labels (or only another chain's) is `400`
      schema:
        type: string
        example: Uniswap V3
    evmExcludeDexes:
      name: excludeDexes
      in: query
      description: >-
        Never these venues, same format as `dexes`. Alias `excludeDex`.
        Excluding every venue of the chain is `404 no_route`
      schema:
        type: string
        example: Uniswap V2
    evmPlatformFeeBps:
      name: platformFeeBps
      in: query
      description: >-
        Only `0` or absent: there is no platform fee on EVM, and above 0 is
        `400`
      schema:
        type: integer
        const: 0
        default: 0
  responses:
    EvmQuote:
      description: The quote (live answers of the public router)
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/EvmQuoteResponse'
          examples:
            buy:
              summary: 0.001 ETH to USDC on Base, one hop on Uniswap V3
              value:
                inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
                inAmount: '1000000000000000'
                outputMint: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'
                outAmount: '2480114'
                otherAmountThreshold: '2455312'
                swapMode: ExactIn
                slippageBps: 100
                priceImpactPct: '0'
                routePlan:
                  - swapInfo:
                      ammKey: '0xb4cb800910b228ed3d0834cf79d697127bbb00e5'
                      label: Uniswap V3
                      inputMint: '0x4200000000000000000000000000000000000006'
                      outputMint: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'
                      inAmount: '1000000000000000'
                      outAmount: '2480114'
                      feeTier: 100
                    percent: 100
                    bps: 10000
                contextSlot: 52397003
                timeTaken: 0.014914167
                quoteId: a94ab99f-de33-40e4-86e8-f9a3d8d3cc90
                chain: base
                chainId: 8453
                router: '0x2626664c2603336e57b271c5c0b26f421741e481'
                gasEstimate: '132900'
                blockHash: >-
                  0x9ff8b4818f3f50f5f468d92bd3285bff54403037e5d4e8596689a065f42da13c
                expiresAt: '2026-10-09T22:02:50.275720839Z'
                candidates: 5
            twoHops:
              summary: >-
                1 CAKE to USDC on BNB Chain, through USDT on PancakeSwap V3
                (maxHops 3)
              value:
                inputMint: '0x0e09fabb73bd3ade0a17ecc321fd13a19e81ce82'
                inAmount: '1000000000000000000'
                outputMint: '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d'
                outAmount: '2183372927996230606'
                otherAmountThreshold: '2161539198716268299'
                swapMode: ExactIn
                slippageBps: 100
                priceImpactPct: '0'
                routePlan:
                  - swapInfo:
                      ammKey: '0xe04d921d6ab7c3ef2eee14dd7a95be5706a1ea93'
                      label: PancakeSwap V3
                      inputMint: '0x0e09fabb73bd3ade0a17ecc321fd13a19e81ce82'
                      outputMint: '0x55d398326f99059ff775485246999027b3197955'
                      inAmount: '1000000000000000000'
                      outAmount: '2185351261030324052'
                      feeTier: 100
                    percent: 100
                    bps: 10000
                  - swapInfo:
                      ammKey: '0x92b7807bf19b7dddf89b706143896d05228f3121'
                      label: PancakeSwap V3
                      inputMint: '0x55d398326f99059ff775485246999027b3197955'
                      outputMint: '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d'
                      inAmount: '2185351261030324052'
                      outAmount: '2183372927996230606'
                      feeTier: 100
                    percent: 100
                    bps: 10000
                contextSlot: 126712376
                timeTaken: 0.160111136
                quoteId: 7e4b19df-2ad8-45d6-9fef-109c8934910c
                chain: bsc
                chainId: 56
                router: '0x1b81d678ffb9c0263b24a97847620c99d213eb14'
                gasEstimate: '278939'
                blockHash: >-
                  0x047a82e98427730cb49ac4c40bf81250ba7fb24e45c5c1df325ebb356effe541
                expiresAt: '2026-10-09T22:02:50.607318247Z'
                candidates: 48
            wrap:
              summary: A wrap, no pool
              value:
                inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
                inAmount: '1000000000000000'
                outputMint: '0x4200000000000000000000000000000000000006'
                outAmount: '1000000000000000'
                otherAmountThreshold: '1000000000000000'
                swapMode: ExactIn
                slippageBps: 50
                priceImpactPct: '0'
                routePlan:
                  - swapInfo:
                      ammKey: '0x4200000000000000000000000000000000000006'
                      label: Wrap
                      inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
                      outputMint: '0x4200000000000000000000000000000000000006'
                      inAmount: '1000000000000000'
                      outAmount: '1000000000000000'
                    percent: 100
                    bps: 10000
                contextSlot: 52397016
                timeTaken: 0.000014286
                quoteId: a25b0a96-bf12-4a84-9084-5535632763fc
                chain: base
                chainId: 8453
                router: '0x4200000000000000000000000000000000000006'
                gasEstimate: '45000'
                blockHash: >-
                  0xc798c67b9f745116fd8defbc64e4117c737130b3c49928be0c92d2b8a8540b6d
                expiresAt: '2026-10-09T22:03:16.144660271Z'
                candidates: 0
    EvmQuoteBadRequest:
      description: >
        Fix the request; retrying will not help. `error` is `bad_request` with a
        sentence that names

        the field (never your value), or `declined` with `reason: zero_amount`.
        Among the causes: a

        missing `chain`, `inputMint`, `outputMint` or `amount`; a `chain` this
        router does not

        serve; an address that is not `0x` and 40 hex digits, or the zero
        address; the same token

        in and out; an `amount` that is not a uint256 in base units (a sign, a
        fraction, an

        exponent, more than 2^256 − 1); `swapMode=ExactOut`; `slippageBps` above
        10000; `dexes`

        naming no venue of the chain; `platformFeeBps` above 0; a body that is
        not a JSON object.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/EvmError'
          examples:
            exactOut:
              summary: swapMode=ExactOut
              value:
                error: bad_request
                reason: 'ExactOut is not served on EVM: this router quotes ExactIn only'
            missing:
              summary: No inputMint
              value:
                error: bad_request
                reason: inputMint is required
            chain:
              summary: A chain that is not EVM
              value:
                error: bad_request
                reason: chain must be eth, bsc, base or robinhood (or its chain id)
            unknownDex:
              summary: dexes=PancakeSwap V3 on Base
              value:
                error: bad_request
                reason: >-
                  dexes names no venue this router serves on base (the venues
                  list has the labels)
            platformFee:
              summary: platformFeeBps=20
              value:
                error: bad_request
                reason: 'platformFeeBps: platform fees are not served on EVM'
            zero:
              summary: amount=0
              value:
                error: declined
                reason: zero_amount
    EvmUnauthorized:
      description: >-
        A missing or unknown API key, or an account out of credits. The body is
        the API's, with its lower-case code.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GateError'
          example:
            error:
              code: unauthorized
              message: missing or unknown API key (send it as x-api-key)
    EvmNoRoute:
      description: >
        `declined` with `no_route`: no executable route on the verified venues
        of the chain under

        these filters and hop limit, with the number of routes tried
        (`candidates`). The pair has

        no pool on these venues, or no route gives a non-zero output for this
        amount. Not an RPC

        failure: those are `503 rpc`. Retrying the same request will not change
        it unless the

        market does.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/EvmError'
          example:
            error: declined
            reason: no_route
            candidates: 4
    EvmQuoteDeclined:
      description: >-
        `declined` with `amount_too_small`: at this slippage the floor would be
        zero. Quote a larger amount or a smaller slippage.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/EvmError'
          example:
            error: declined
            reason: amount_too_small
    EvmRateLimited:
      description: >-
        Over the account's limit a minute (shared with the API, the Solana
        routes and launch). Wait for the next minute.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GateError'
          example:
            error:
              code: rate_limited
              message: too many requests
    EvmNotReady:
      description: >
        Retry with backoff. `error` is `not_ready` with `reasons` (the chain has
        no RPC, no venue

        verified yet, or none of the venues `dexes` asked for is verified; or
        too many quotes and

        builds are in flight, then with `Retry-After: 1`), or `rpc` with the
        kind of failure as

        `reason`: the router could not read the chain (`rpc_timeout`,
        `rpc_block_unavailable`,

        `rpc_unavailable`, `rpc_queue_full`, …), or the request took more than
        10 seconds

        (`request_timeout`). Not a lack of liquidity, which is `404 no_route`.
      headers:
        Retry-After:
          description: '`1` when too many quotes and builds are in flight'
          schema:
            type: integer
      content:
        application/json:
          schema:
            anyOf:
              - $ref: '#/components/schemas/NotReadyError'
              - $ref: '#/components/schemas/EvmError'
          examples:
            venue:
              summary: No requested venue is verified (shape from the code)
              value:
                error: not_ready
                reasons:
                  - 'base: none of the requested venues is verified yet'
            overloaded:
              summary: Too many requests in flight (shape from the code)
              value:
                error: not_ready
                reasons:
                  - 'overloaded: too many quotes and builds in flight'
            rpc:
              summary: The node did not answer in time (shape from the code)
              value:
                error: rpc
                reason: rpc_timeout
  schemas:
    EvmQuoteResponse:
      type: object
      required:
        - inputMint
        - inAmount
        - outputMint
        - outAmount
        - otherAmountThreshold
        - swapMode
        - slippageBps
        - priceImpactPct
        - routePlan
        - contextSlot
        - timeTaken
        - quoteId
        - chain
        - chainId
        - router
        - gasEstimate
        - blockHash
        - expiresAt
        - candidates
      properties:
        inputMint:
          type: string
          description: >-
            Lower case; the native coin is
            `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`
        inAmount:
          type: string
          description: 'What you spend: the `amount` asked'
        outputMint:
          type: string
        outAmount:
          type: string
          description: >-
            What the route gives at the quote's block, in base units of
            `outputMint`, before any tax the token itself takes
        otherAmountThreshold:
          type: string
          description: >-
            The floor the swap will enforce on chain: `outAmount × (10000 −
            slippageBps) / 10000`, rounded down (`inAmount` for a wrap or an
            unwrap)
        swapMode:
          type: string
          const: ExactIn
        slippageBps:
          type: integer
        priceImpactPct:
          type: string
          const: '0'
          description: 'Not computed on EVM: always `0`'
        routePlan:
          type: array
          items:
            $ref: '#/components/schemas/EvmRoutePlanStep'
          description: One step per hop, in order
        contextSlot:
          type: integer
          description: The block number the quote was priced at
        timeTaken:
          type: number
          description: Seconds spent inside the router
        quoteId:
          type: string
          format: uuid
          description: What `POST /evm/swap` builds, until `expiresAt`
        chain:
          $ref: '#/components/schemas/EvmChainSlug'
        chainId:
          type: integer
        router:
          type: string
          description: >-
            The contract the swap transaction goes to: the venue's router (also
            the approvals' spender), or the wrapped token for a wrap or an
            unwrap
        gasEstimate:
          type: string
          description: >-
            Indicative (QuoterV2 on V3, a fixed estimate per hop on V2). The
            build's simulation gives the real figure
        blockHash:
          type: string
          description: The hash of the block the quote was priced at
        expiresAt:
          type: string
          format: date-time
          description: >-
            Until when the quote can be built: the chain's `quoteTtlSecs` after
            quoting (15 s; 30 s on `eth`)
        candidates:
          type: integer
          description: Routes priced (0 for a wrap or an unwrap)
    EvmError:
      type: object
      description: >-
        An error of the EVM routes: the Solana routes' shape, without `quoteId`.
        `not_ready` carries `reasons` instead (`NotReadyError`)
      required:
        - error
        - reason
      properties:
        error:
          type: string
          enum:
            - bad_request
            - declined
            - quote_mismatch
            - route_expired
            - rpc
            - not_found
          description: Closed error code
        reason:
          type: string
          description: >-
            With `declined`, a stable label: `no_route`, `zero_amount`,
            `amount_too_small`, `quote_stale`, `recipient_unsupported`. With
            `rpc`, the kind of failure in lower case: `rpc_timeout`,
            `rpc_block_unavailable`, `rpc_unavailable`, `rpc_queue_full`,
            `request_timeout`, …. Otherwise a sentence for humans. Never your
            input, a URL, a key or a provider's message
        candidates:
          type: integer
          description: '`no_route`: routes tried'
        outAmount:
          type:
            - string
            - 'null'
          description: >-
            `quote_stale`: what the route gives now, `null` if it no longer
            executes
        otherAmountThreshold:
          type: string
          description: '`quote_stale`: the floor it had to reach'
    GateError:
      type: object
      description: >-
        The API key gate's error, the market-data API's shape: `unauthorized`
        (401) or `rate_limited` (429)
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              enum:
                - unauthorized
                - rate_limited
            message:
              type: string
    NotReadyError:
      type: object
      required:
        - error
        - reasons
      properties:
        error:
          type: string
          const: not_ready
        reasons:
          type: array
          items:
            type: string
          description: Every reason the router cannot serve this request now
        quoteId:
          type: string
    EvmRoutePlanStep:
      type: object
      required:
        - swapInfo
        - percent
        - bps
      properties:
        swapInfo:
          $ref: '#/components/schemas/EvmSwapInfo'
        percent:
          type: integer
          const: 100
          description: 'Always 100: EVM routes do not split'
        bps:
          type: integer
          const: 10000
    EvmChainSlug:
      type: string
      enum:
        - eth
        - bsc
        - base
        - robinhood
      description: '`eth` (chain id 1), `bsc` (56), `base` (8453), `robinhood` (4663)'
    EvmSwapInfo:
      type: object
      required:
        - ammKey
        - label
        - inputMint
        - outputMint
        - inAmount
        - outAmount
      properties:
        ammKey:
          type: string
          description: The pool; for a wrap or an unwrap, the wrapped-token contract
        label:
          type: string
          description: >-
            The venue's `dex` label (`Uniswap V3`, `PancakeSwap V2`, …), or
            `Wrap` / `Unwrap`
        inputMint:
          type: string
          description: >-
            The hop's input. Inside a route the wrapped token stands for the
            native coin; a `Wrap` step's input is the native coin
        outputMint:
          type: string
          description: The hop's output; an `Unwrap` step's output is the native coin
        inAmount:
          type: string
          description: Input of this hop, in base units
        outAmount:
          type: string
          description: Output of this hop, in base units
        feeTier:
          type: integer
          description: >-
            V3 only: the pool's fee tier in hundredths of a basis point (`100`
            is 0.01%, `3000` is 0.3%)
  securitySchemes:
    ApiKeyHeader:
      type: apiKey
      in: header
      name: x-api-key
    Bearer:
      type: http
      scheme: bearer
    ApiKeyQuery:
      type: apiKey
      in: query
      name: apiKey

````

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