> ## 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 (JSON body)

> The same quote as `GET /evm/quote`, with the parameters as a JSON object, read as JSON
whatever the `Content-Type` and at most 256 KiB. Numeric fields accept a number or a
decimal string (`amount` as a JSON number only up to 2^64 − 1: send larger amounts as
strings); `dexes` / `excludeDexes` accept a comma-separated string or an array; booleans
must be JSON booleans. Unknown fields are ignored. A body that is not a JSON object is
`400 bad_request` with the parser's message, which names a position, never your input.


The same quote as [`GET /evm/quote`](/api-reference/router/evm-quote), with the parameters in a JSON body. Guide: [EVM swaps](/router/evm#the-quote).


## OpenAPI

````yaml router.openapi.yaml POST /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:
    post:
      tags:
        - EVM swap
      summary: Quote an EVM swap (JSON body)
      description: >
        The same quote as `GET /evm/quote`, with the parameters as a JSON
        object, read as JSON

        whatever the `Content-Type` and at most 256 KiB. Numeric fields accept a
        number or a

        decimal string (`amount` as a JSON number only up to 2^64 − 1: send
        larger amounts as

        strings); `dexes` / `excludeDexes` accept a comma-separated string or an
        array; booleans

        must be JSON booleans. Unknown fields are ignored. A body that is not a
        JSON object is

        `400 bad_request` with the parser's message, which names a position,
        never your input.
      operationId: evmPostQuote
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/EvmQuoteRequest'
            examples:
              twoHops:
                summary: 1 CAKE to USDC on BNB Chain, up to 3 hops
                value:
                  chain: bsc
                  inputMint: '0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82'
                  outputMint: '0x8AC76a51cc950d9822d68b83fE1Ad97B32Cd580d'
                  amount: '1000000000000000000'
                  slippageBps: 100
                  maxHops: 3
              buy:
                summary: 0.001 ETH to USDC on Base, 1% slippage
                value:
                  chain: base
                  inputMint: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
                  outputMint: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
                  amount: '1000000000000000'
                  slippageBps: 100
              wrap:
                summary: Wrap 0.001 ETH into WETH on Base
                value:
                  chain: base
                  inputMint: native
                  outputMint: '0x4200000000000000000000000000000000000006'
                  amount: '1000000000000000'
      responses:
        '200':
          $ref: '#/components/responses/EvmQuote'
        '400':
          $ref: '#/components/responses/EvmQuoteBadRequest'
        '401':
          $ref: '#/components/responses/EvmUnauthorized'
        '404':
          $ref: '#/components/responses/EvmNoRoute'
        '413':
          $ref: '#/components/responses/TooLarge'
        '422':
          $ref: '#/components/responses/EvmQuoteDeclined'
        '429':
          $ref: '#/components/responses/EvmRateLimited'
        '503':
          $ref: '#/components/responses/EvmNotReady'
components:
  schemas:
    EvmQuoteRequest:
      type: object
      required:
        - chain
        - inputMint
        - outputMint
        - amount
      properties:
        chain:
          type:
            - string
            - integer
          description: >-
            `eth`, `bsc`, `base` or `robinhood` (also `ethereum`, `bnb`), or the
            chain id as a number or a string. Alias `chainId`
          example: base
        inputMint:
          $ref: '#/components/schemas/EvmMint'
          description: Token you spend
        outputMint:
          $ref: '#/components/schemas/EvmMint'
          description: Token you receive; different from `inputMint`
        amount:
          type:
            - string
            - integer
          description: >-
            What you spend, a uint256 in the token's smallest unit: a decimal
            string (any size up to 2^256 − 1) or a JSON integer (up to 2^64 −
            1). No sign, fraction or exponent; `0` is `400 declined zero_amount`
        swapMode:
          type: string
          enum:
            - ExactIn
            - exactIn
          default: ExactIn
          description: '`ExactOut` is `400`'
        slippageBps:
          type:
            - integer
            - string
          default: 50
          description: >-
            0–10000: the floor is `outAmount × (10000 − slippageBps) / 10000`,
            rounded down
        maxHops:
          type:
            - integer
            - string
          default: 2
          description: >-
            1 direct only, 2 through at most one intermediate token, 3 two. 0
            counts as 1, more than 3 as 3
        onlyDirectRoutes:
          type: boolean
          default: false
          description: '`true` is `maxHops` 1'
        dexes:
          oneOf:
            - type: string
            - type: array
              items:
                type: string
          description: >-
            Only these venues: `dex` labels or venue ids from `/evm/venues`.
            Alias `includeDex`
        excludeDexes:
          oneOf:
            - type: string
            - type: array
              items:
                type: string
          description: Never these venues. Alias `excludeDex`
        platformFeeBps:
          type:
            - integer
            - string
          const: 0
          description: 'Only 0: no platform fee on EVM'
    EvmMint:
      type: string
      description: >-
        A token: its address (`0x` and 40 hex digits, any case), or the chain's
        native coin, `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` or `native`.
        The zero address is refused. Answers write addresses in lower case, the
        native coin as `0xeeee…eeee`
      example: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
    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%)
  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
    TooLarge:
      description: The request body is over 256 KiB (plain-text body)
      content:
        text/plain:
          schema:
            type: string
    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
  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.