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

> ## Agent Instructions
> If you are an agent buying services: start with these steps. Every page has a .md version.
> 1. Install the Catalog MCP (live server https://mcp.live.nevermined.app/mcp, sandbox server https://mcp.sandbox.nevermined.app/mcp; rehearse on sandbox with a sandbox API key before live, as keys work only in their own environment; Claude Code and Cursor commands, Codex config.toml entry): https://nevermined.ai/docs/products/catalog/mcp.md
> 2. Get an API key: https://nevermined.ai/docs/agents-guide/get-api-key.md
> 3. Enroll a card and create a delegation (a payment method plus a spend mandate: an amount, an expiry and a number of purchases): https://nevermined.ai/docs/agents-guide/enroll-card.md
> 4. Buy and call a paid agent over x402: https://nevermined.ai/docs/getting-started/ai-agent-purchase.md
> SDK quickstart: https://nevermined.ai/docs/integrate/quickstart/typescript.md. Pricing: https://nevermined.ai/pricing/

# Download Payment Result

> The response body of a paid call, exactly as `GET /api/v1/router/payments/{id}/result`
would relay it, but as the bytes themselves instead of JSON: binary media (audio, images,
PDFs) comes back decoded rather than base64, served with the content type the service gave
it and `Content-Disposition: attachment`. `X-Upstream-Status` carries the service’s HTTP
status. Same access, scope and 24-hour retention as `/result`.

- `200` — the body bytes. A streamed call (`/router/proxy`, `/router/svc`) is served byte for
  byte as the service sent it; a `/router/route` text body is served as UTF-8.
- `204` — no body to return: none was sent, or a non-2xx body of a `/router/route` result
  was withheld. A streamed call’s withheld error is stored as the Router’s typed
  `BCK.ROUTER.0019`/`0020` JSON, so it is answered `200` `application/json`, with the
  service’s 4xx/5xx in `X-Upstream-Status` (a catalog call’s 402 re-challenge is withheld with
  no body, so a `204`).
- `202` — still running: the same JSON document `/result` answers (`state: Pending`). Poll
  `/result` until it is `Ready`, then fetch this.
- `409` `BCK.ROUTER.0050` — nothing to download: the retained result is `Failed` (the call
  may still have been delivered and charged; read `/result` for `failureReason`), or its
  stored body cannot be read.
- `404` `BCK.ROUTER.0030` — the result expired, was never retained or is not yours.



## OpenAPI

````yaml GET /router/payments/{id}/result/content
openapi: 3.1.0
info:
  title: Nevermined API
  description: >-
    API for managing AI agents, payment plans, and x402 payments in the
    Nevermined ecosystem.


    ## Prerequisites


    You need a Nevermined API Key to authenticate. Get one at
    [nevermined.app](https://nevermined.app) under **Settings > API Keys**.


    See the [5-Minute Setup Guide](/docs/integrate/quickstart/5-minute-setup)
    for detailed instructions.
  license:
    name: MIT
  version: 1.0.0
  x-nevermined-credit-size-since: '2026-11-10'
servers:
  - url: https://api.sandbox.nevermined.app/api/v1
    description: Sandbox (Testing) - Base Sepolia
  - url: https://api.live.nevermined.app/api/v1
    description: Live (Production) - Base Mainnet
security:
  - bearerAuth: []
tags:
  - name: Protocol - Agents
    description: Endpoints for registering and managing AI agents
  - name: Protocol - Plans
    description: Endpoints for creating and managing payment plans
  - name: Protocol - Credits
    description: Endpoints for minting and redeeming credits
  - name: Protocol - Access
    description: Endpoints for access tokens and request validation
  - name: X402 - Permissions
    description: Endpoints for x402 delegated permissions
paths:
  /router/payments/{id}/result/content:
    get:
      tags:
        - Router
      summary: Download a paid Router result as raw bytes (retained for 24 hours)
      description: >-
        The response body of a paid call, exactly as `GET
        /api/v1/router/payments/{id}/result`

        would relay it, but as the bytes themselves instead of JSON: binary
        media (audio, images,

        PDFs) comes back decoded rather than base64, served with the content
        type the service gave

        it and `Content-Disposition: attachment`. `X-Upstream-Status` carries
        the service’s HTTP

        status. Same access, scope and 24-hour retention as `/result`.


        - `200` — the body bytes. A streamed call (`/router/proxy`,
        `/router/svc`) is served byte for
          byte as the service sent it; a `/router/route` text body is served as UTF-8.
        - `204` — no body to return: none was sent, or a non-2xx body of a
        `/router/route` result
          was withheld. A streamed call’s withheld error is stored as the Router’s typed
          `BCK.ROUTER.0019`/`0020` JSON, so it is answered `200` `application/json`, with the
          service’s 4xx/5xx in `X-Upstream-Status` (a catalog call’s 402 re-challenge is withheld with
          no body, so a `204`).
        - `202` — still running: the same JSON document `/result` answers
        (`state: Pending`). Poll
          `/result` until it is `Ready`, then fetch this.
        - `409` `BCK.ROUTER.0050` — nothing to download: the retained result is
        `Failed` (the call
          may still have been delivered and charged; read `/result` for `failureReason`), or its
          stored body cannot be read.
        - `404` `BCK.ROUTER.0030` — the result expired, was never retained or is
        not yours.
      operationId: getRouterPaymentResultContent
      parameters:
        - name: id
          required: true
          in: path
          description: The `paymentId` of the paid call.
          schema:
            example: b1f9c2e4-8a3d-4f27-9c6b-5d2e17a04f8b
            type: string
      responses:
        '200':
          description: The body bytes, with the service’s content type.
          headers:
            X-Upstream-Status:
              description: >-
                The HTTP status the service answered the paid call with. A
                non-2xx value means the call did not deliver what was paid for,
                whatever this download's own status.
              schema:
                type: string
            Content-Disposition:
              description: >-
                `attachment; filename="<paymentId>"`, with no extension: name a
                saved file from `Content-Type`.
              schema:
                type: string
          content:
            '*/*':
              schema:
                type: string
                format: binary
        '202':
          description: 'The paid call is still running (`state: Pending`).'
          headers:
            Location:
              description: The `/result` URL to poll until it is `Ready`.
              schema:
                type: string
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RouterPaymentResultDto'
        '204':
          description: >-
            No body to return: none was sent, or a non-2xx body of a
            `/router/route` result was withheld. A streamed call’s withheld
            error is a `200` `application/json` instead, with its status in
            `X-Upstream-Status` (a catalog call’s 402 re-challenge is withheld
            with no body, so a `204`).
          headers:
            X-Upstream-Status:
              description: >-
                The HTTP status the service answered the paid call with. A
                non-2xx value means the call did not deliver what was paid for,
                whatever this download's own status.
              schema:
                type: string
        '400':
          description: '`id` is not a valid uuid (BCK.HTTP.400).'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RouterErrorResponseDto'
        '401':
          description: Missing/invalid Nevermined API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RouterErrorResponseDto'
        '404':
          description: >-
            No retained result for this id under your account — expired, never
            retained, or not yours (BCK.ROUTER.0030).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RouterErrorResponseDto'
        '409':
          description: >-
            Nothing to download: the retained result is Failed (the call may
            still have been delivered and charged), or its stored body cannot be
            read (BCK.ROUTER.0050).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RouterErrorResponseDto'
components:
  schemas:
    RouterPaymentResultDto:
      type: object
      description: A paid Router result retained for its payer for 24 hours.
      properties:
        paymentId:
          type: string
          example: b1f9c2e4-3d5a-4c7e-9f21-6a8b0c4d2e13
        state:
          type: string
          enum:
            - Pending
            - Ready
            - Failed
          example: Ready
        resultUrl:
          type: string
          example: /api/v1/router/payments/b1f9c2e4-3d5a-4c7e-9f21-6a8b0c4d2e13/result
        expiresAt:
          type: string
          description: When the result is deleted. Until then only you can read it.
          example: '2026-09-26T10:12:00.000Z'
        status:
          type:
            - number
            - 'null'
          description: The upstream HTTP status of the paid call. `Ready` only.
          example: 200
        body:
          description: >-
            The relayed response body, exactly as the original call would have
            returned it — a cataloged service's non-2xx body is withheld (null).
            Its form is named by `bodyEncoding`. `Ready` only.
          example:
            ok: true
        bodyEncoding:
          type:
            - string
            - 'null'
          enum:
            - json
            - text
            - base64
            - null
          description: >-
            `json` — the parsed JSON value; `text` — a UTF-8 string; `base64` —
            binary, base64-encoded. Null when there is no body.
        contentType:
          type:
            - string
            - 'null'
          description: >-
            The upstream content type, for a streamed call (`/router/proxy`,
            `/router/svc`).
        headers:
          type: object
          additionalProperties:
            type: string
          description: >-
            The response headers the streamed call would have relayed. Empty for
            a `/router/route` result.
        failureReason:
          type:
            - string
            - 'null'
          description: Why a `Failed` result has no response.
        payment:
          $ref: '#/components/schemas/RouterPaymentResultPaymentDto'
      required:
        - paymentId
        - state
        - resultUrl
        - expiresAt
        - payment
    RouterErrorResponseDto:
      type: object
      properties:
        code:
          type: string
          description: >-
            Router error code. `BCK.ROUTER.0001` invalid request / no fundable
            option / bad 402 (400); `BCK.ROUTER.0002` requestId already used —
            idempotency conflict (409); also returned by `/router/select` itself
            when a payment already exists for this requestId (a retry that can
            no longer re-select the paid service), carrying the original
            paymentId; `BCK.ROUTER.0003` delegation budget exceeded, expired, or
            inactive (402); `BCK.ROUTER.0004` payment record not found (404);
            `BCK.ROUTER.0005` payment not in a settleable state (409);
            `BCK.ROUTER.0006` failed to build the payments summary (500);
            `BCK.ROUTER.0007` too many concurrent mode-B relays — retryable
            (429); `BCK.ROUTER.0008` the Router needs an EIP-7702 (v2) API key
            (403); `BCK.ROUTER.0009` insufficient wallet balance, or the card
            was declined (402); `BCK.ROUTER.0010` the amount to charge against
            the cap could not be determined (500); `BCK.ROUTER.0011` the card
            needs 3-D Secure cardholder authentication (402); `BCK.ROUTER.0012`
            the seller advertised an EIP-712 domain its own settlement token
            does not sign under — the seller’s bug (400); `BCK.ROUTER.0013`
            Nevermined holds no EIP-712 domain for the selected settlement token
            — ours, not the seller’s, and not retryable (500); `BCK.ROUTER.0014`
            this target is a cataloged Nevermined service — invoke it through
            the broker by its catalog slug (`/router/route` with `slug`, or
            `/router/svc/:slug`) instead of by raw URL (409). `BCK.ROUTER.0018`
            the fee-inclusive price exceeds maxTotalCents; params gives
            requiredTotalMicros, requiredTotalCents, merchantCents, feeCents and
            maxTotalCents (402, no charge). `BCK.ROUTER.0019` a cataloged
            service returned a non-retryable status — a client error (4xx), or a
            rare 3xx the Router does not follow (a 402 re-challenge and a 429
            are NOT this code): the Router withholds the upstream body (it can
            name the merchant host) and returns this typed body with the
            original status preserved — build a valid request from the service’s
            Catalog detail; not retryable. `BCK.ROUTER.0020` a cataloged service
            returned a server error (5xx) or rate-limited (429): same
            withholding, original status preserved — an upstream/transient
            condition, retryable (back off); also an unpaid request the service
            did not answer at all (timeout or connection failure, 502).
            `BCK.ROUTER.0021` the payment credential would overwrite a header
            you asked the Router to forward — the rail this service advertised
            carries its credential in that header (on the MPP rails,
            `Authorization`, which is also where your own merchant auth goes):
            name the header the service documents for the credential via
            `credentialHeader` / `X-Router-Credential-Header`; nothing was
            minted and no money moved (400, not retryable). `BCK.ROUTER.0022` a
            required Router capability (service selection or buyer identity) is
            not configured — a server wiring/configuration fault before egress
            or minting; retry after the operator restores it (500, retryable).
            `BCK.ROUTER.0023` on a `/router/select` autoPay the charge outcome
            for this requestId is indeterminate — either the downstream call did
            not complete cleanly after the payment was created, or the Router
            could not determine whether an earlier attempt on this requestId
            charged (including when there was none): reconcile via `GET
            /api/v1/router/payments` and reuse the SAME requestId to retry
            safely; params carries the paymentId when one is known (502, not
            retryable). `BCK.ROUTER.0024` the Router JSON request body exceeds 5
            MiB (413). `BCK.ROUTER.0025` the upstream reply was too large to
            deliver after a paid request; the payment may have gone through —
            reconcile via `GET /api/v1/router/payments` and do NOT retry with a
            fresh requestId (502, indeterminate). `BCK.ROUTER.0026` the
            streaming surfaces (`/router/svc/:slug`, `/router/proxy`) cannot
            forward this request body, refused before anything is paid: only
            JSON or a URL-encoded form is forwarded (resend in one of those),
            and no body at all on GET/HEAD (send none, or use POST/PUT if the
            service takes one); params names the refused content type, null when
            absent (415, not retryable). `BCK.ROUTER.0027` a slug-routed request
            body is larger than the catalog endpoint accepts (its
            `maxRequestBytes` on the catalog service detail), refused before the
            service is contacted or anything is paid; params gives bodyBytes and
            maxRequestBytes — shrink the body or pick a service that takes it
            (413, not retryable). `BCK.ROUTER.0028` `/router/quote` could not
            price the call because a read it depends on failed; nothing was
            signed or charged (503, retryable). `BCK.ROUTER.0029` quoteId is
            unknown or belongs to another account (404, no charge).
            `BCK.ROUTER.0030` no retained result for that paymentId under your
            account — expired (results are kept 24 hours), never retained, or
            not your payment; deliberately one answer (404). `BCK.ROUTER.0031`
            the exact service named by filters.require cannot be selected (409,
            no charge). `BCK.ROUTER.0032` quoteId expired before payment began
            (410, no charge). `BCK.ROUTER.0033` quoteId does not match this
            request, delegation, rail or exact total (409, no charge).
            `BCK.ROUTER.0034` a paid request got no response from the service
            (timeout or connection failure); the payment may have gone through —
            params carries the paymentId: reconcile via `GET
            /api/v1/router/payments/{paymentId}` and do NOT retry with a fresh
            requestId (502, indeterminate). `BCK.ROUTER.0035` the service
            challenge asks for no payment (a zero amount, typically an auth-only
            wallet sign-in challenge); the request is not malformed and nothing
            was signed or charged (422, not retryable). `BCK.ROUTER.0036` every
            catalog endpoint a slug-routed call reaches answers after the Router
            abandons a paid call (120 s), so paying would charge and deliver
            nothing; refused before the service is contacted or anything is
            paid; params.source is declared (permanent) or observed (lifts at
            params.liftsAt) — pick another endpoint or service (422, not
            retryable). `BCK.ROUTER.0040` the Router refused an inconsistent
            read or write of its MPP session payment-channel state — a
            server-side defect, refused before the credential reached the
            service, so nothing moved (500, not retryable). `BCK.ROUTER.0041`
            `POST /router/payments` met a service paid only over an MPP session
            (a payment channel), which only the Router-fetched routes
            (`/router/route`, `/router/svc`, `/router/proxy`) can pay; answered
            for every crypto delegation there, including one created with
            `allowSessionPayments: false`; nothing was signed or charged (400,
            not retryable). `BCK.ROUTER.0042` the MPP session payment channel
            with this service is closing (its deposit reached its ceiling, or
            the service refused the channel, a top-up, or the payment after a
            top-up), so nothing can be signed on it until it closes; no payment
            was signed, reserved or charged (a top-up the Router sent only moves
            the wallet’s own funds into its channel) — retry later with the same
            requestId, and the next call after the close opens a new channel
            (409, retryable). `BCK.ROUTER.0043` the MPP session payment channel
            with this service is busy — another payment on it held it too long,
            the wallet's signer or balance read did not answer in time, or a
            top-up of the channel was in flight or the service could not be
            reached to take one (`params.stage`); nothing was signed, reserved
            or charged — retry after a few seconds (503, retryable).
            `BCK.ROUTER.0044` a session’s routing fee is collected later in one
            transfer, never per call, and the Router cannot collect it for this
            MPP session payment: `params.cause` is `org-wallet` (an organization
            wallet funds it — pay from a delegation funded by your own wallet)
            or `network` (this deployment does not collect session fees on that
            network); nothing was signed, reserved or charged (422, not
            retryable). `BCK.ROUTER.0045` you pinned a payment rail with
            `requireProtocol` and the service does not offer it, so the Router
            refused rather than pay on the other rail; params gives
            requireProtocol and the rails the 402 offered — use another service,
            or report to the human, who can deliberately drop the pin or pin the
            rail it offers (409, no charge). `BCK.ROUTER.0046` you set
            `validateRequestBody` and the request body provably fails the
            endpoint’s published request schema, so the Router refused before
            charging; params gives endpointPath — fix the body to match the
            published schema/example, or drop the flag (400, no charge).
            `BCK.ROUTER.0047` this delegation was created with
            `allowSessionPayments: false` and the Router would pay the service
            over an MPP session, which locks a refundable deposit at the first
            call; use a service that charges per call, or report to the human,
            who can deliberately drop a `requireProtocol: "mpp"` pin or create a
            delegation that allows them (409, no charge); raised by the routes
            and quotes that can pay a session, never by `POST /router/payments`,
            which answers `BCK.ROUTER.0041` instead. `BCK.ROUTER.0048` on an MPP
            `tempo` payment, Privy did not answer when the Router read the
            wallet’s public key (done once per wallet); nothing was signed,
            reserved or charged — retry after a backoff with the same requestId
            (503, retryable). `BCK.ROUTER.0049` `/router/select` found payable
            services but none reaches the relevance floor (a service not yet
            indexed for semantic scoring passes on a keyword match, and while
            semantic ranking is unavailable the floor applies to none), so it
            chose none and nothing was charged, even on autoPay; params gives
            bestSemanticScore and minSemanticScore — rephrase or broaden the
            intent, or name a slug in filters.require (422, not retryable
            unchanged). `BCK.ROUTER.0050` `GET
            /router/payments/{id}/result/content` has nothing to download: the
            retained result's `state` is Failed (not the payment's `status`: a
            delivered, charged call can end this way), or, rarely, its stored
            body cannot be read — read `/result` (a Failed result carries
            `failureReason`; an unreadable one answers Ready with the body),
            then check `deliveryStatus` by `requestId` before paying again (409,
            not retryable). `BCK.ROUTER.0051` `/router/select`: a catalog
            service close enough to the intent is unhealthy or held by
            moderation right now and nothing else could be chosen; nothing was
            charged, even on autoPay — retry later, or browse candidates with
            ARD search (409, retryable). `BCK.ROUTER.0052` `/router/select` with
            autoPay while semantic ranking is unavailable: the Router will not
            pay a pick it could only make on keywords (a filters.require pin is
            still paid); nothing was charged — retry later with the same
            requestId, or select without autoPay and pay the pick yourself (503,
            retryable). `BCK.ARD.0001` `/router/select` was given an unsupported
            catalog filter term (400). The spend routes, and `GET
            /router/delegations/:id`, can also return `BCK.DELEGATION.0002` (no
            such delegation for this caller, 404); that read additionally
            returns `BCK.DELEGATION.0009` when `:id` is not a v4 uuid (400). The
            spend routes can also return `BCK.OAUTH.0030` (an OAuth-minted
            credential may not spend here, 403), `BCK.OAUTH.0033` (this route
            needs a commerce grant — the OAuth-only `/router/commerce/*` routes,
            403), `BCK.OAUTH.0034` (a `delegationId` was supplied to one of
            them, where it is derived from the grant instead, 400),
            `BCK.OAUTH.0039` (a credits-only commerce grant must use
            subscription credit routes or reconnect with a stablecoin cap, 403),
            `BCK.X402.0011` (no Privy wallet for this account, 404),
            `BCK.X402.0053` (the account’s embedded wallet was deleted, 404) and
            `BCK.X402.0052` (the wallet’s EIP-7702 upgrade could not be
            completed — usually transient, retryable, 503); the check that a
            personal wallet belongs to the account can return
            `BCK.USER_PROFILE.0005` (it does not, 403), `BCK.USER_PROFILE.0006`
            (Privy or the RPC did not answer — transient, retryable, 503) or
            `BCK.USER_PROFILE.0007` (it failed for a reason retrying will not
            fix, 500); a `slug` that names no listed catalog service returns
            `BCK.CATALOG.0001` (404); and, for an organization-wallet
            delegation, `BCK.BUDGETS.0003` / `BCK.BUDGETS.0006` (422); and `POST
            /router/payments` refuses a body asking for subscription funding
            with `BCK.SUBSCRIPTION_ROUTER.0007` (400). Framework-level
            `BCK.HTTP.*` codes (e.g. `BCK.HTTP.400` request validation,
            `BCK.HTTP.429` throttling) may also appear — see the base `code`
            field.
          example: BCK.ROUTER.0003
        httpStatus:
          type: number
          description: HTTP status code
          example: 500
        message:
          type: string
          description: Error message for Router operations.
          example: delegation budget exceeded, expired, or inactive
          examples:
            - >-
              delegationId is required — create one via POST
              /api/v1/delegation/create
            - 'no fundable option; offered: [...]'
            - >-
              upstream pay-to address is not in this delegation's allowed
              recipients
            - delegation budget exceeded, expired, or inactive
            - payment already settled with a different txHash
        details:
          type: string
          description: >-
            Throw-site detail string supplementing the canonical message. Only
            set when the call site supplied an opts.message; absent otherwise.
          example: Hash JWT is not signed by the node account
        error:
          type: string
          description: >-
            RFC 6749 §5.2 / RFC 8628 §3.5 top-level OAuth error string. Present
            only on the OAuth device-polling responses from `POST /oauth/token`
            (`authorization_pending`, `slow_down`, `expired_token`,
            `access_denied`), so a standards-compliant OAuth/device client can
            branch on it directly instead of on the Nevermined `code`. Absent on
            every other error.
          example: authorization_pending
        hint:
          type: string
          description: >-
            Actionable remediation hint, sourced from the catalogue or supplied
            at the throw site. Tells the caller what to fix or where to look.
          example: >-
            Verify the wallet has sufficient balance and that the plan is
            active.
        docsUrl:
          type: string
          description: Permalink to the docs page describing this error code.
          example: >-
            https://nevermined.ai/docs/development-guide/api-errors/codes#bck-x402-0008
        category:
          type: string
          description: >-
            Coarse classification of the failure, useful for client-side
            branching without parsing the message.
          enum:
            - validation
            - auth
            - business
            - integration
            - internal
          example: integration
        retryable:
          type: boolean
          description: >-
            Whether the failure is transient and the same call can be retried
            with identical inputs. Absent when the catalogue does not assert
            either way.
          example: true
        correlationId:
          type: string
          description: >-
            Request-scoped correlation id stamped by the global filter. Echoed
            in the x-correlation-id response header. Quote this when reporting
            issues.
          example: a3f6b1c4-7d2e-4a9b-8e0c-12f4d8e6c5b9
        uuid:
          type: string
          description: >-
            Per-error UUID generated at construction. Useful for log
            correlation.
          example: e-550e8400-e29b-41d4-a716-446655440000
        date:
          type: string
          description: ISO timestamp at which the error was constructed.
          example: '2026-05-09T12:34:56.789Z'
          format: date-time
        params:
          type: string
          description: >-
            JSON-stringified contextual parameters supplied at the throw site
            (e.g. IDs, state). Always a string in the wire format — parse with
            JSON.parse if needed.
          example: '{"planId":"43298432984329","reason":"Invalid configuration"}'
      required:
        - code
        - httpStatus
        - message
    RouterPaymentResultPaymentDto:
      type: object
      properties:
        paymentId:
          type: string
          example: b1f9c2e4-3d5a-4c7e-9f21-6a8b0c4d2e13
        status:
          type: string
          enum:
            - Issued
            - Settled
            - Failed
          example: Settled
        txHash:
          type:
            - string
            - 'null'
          description: The settlement reference, once the merchant reported one.
      required:
        - paymentId
        - status
        - txHash
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your Nevermined API Key (starts with 'nvm:'). Get one at
        [nevermined.app](https://nevermined.app) under **Settings > API Keys**.

````

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