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

# Chains and tokens this account accepts

> Scoped to the caller, not the global catalogue. A headless integration built
off the full catalogue offers assets the merchant never enabled, and the
payer only finds out when the charge is refused.

Tokens come nested under their chain. A chain's name, icon and payable
`modes` are facts about the CHAIN, so they are stated once per chain
rather than repeated on every token · the payload grows with the number
of chains, not with the catalogue.

`modes` says how a chain's tokens can actually be paid. Bitcoin is
deposit-only · it has no contracts to sign against · so a UI that renders
a "connect wallet" button on it builds a flow the API refuses.

SANDBOX returns testnet chains, LIVE mainnet: a sandbox integration is
never handed a mainnet address to send real funds to.




## OpenAPI

````yaml /v3-beta/api-reference/openapi.yaml get /v3/crypto/assets
openapi: 3.1.0
info:
  title: Suby.fi Merchant API
  version: 3.0.0-beta
  description: >
    The **v3** public merchant API for Suby.fi. RESTful (plural,
    resource-oriented

    endpoints under the `/v3` prefix). Authenticate every request

    with your secret API key in the `X-Suby-Api-Key` header.


    - `sk_live_…` keys operate in **production** (real funds).

    - `sk_sandbox_…` keys operate in a fully simulated **sandbox** (test cards,
      Base Sepolia crypto, no real money). The environment is derived from the
      key prefix.
  contact:
    email: contact@suby.fi
    url: https://suby.fi
servers:
  - url: https://api.beta.suby.fi
    description: Production + sandbox (environment selected by API key prefix)
security:
  - ApiKeyAuth: []
tags:
  - name: Products
    description: Manage your product catalog (one-time and recurring).
  - name: Checkout
    description: >-
      Hosted checkout · signed session tokens (`cs_…`). Every card Suby holds
      was collected here, which is what keeps card data out of your systems.
  - name: Payments
    description: >-
      Read payments and receipts, refund them, and debit a stored instrument
      off-session (pay-as-you-go). Collecting a card happens on the hosted
      checkout, never here.
  - name: Subscriptions
    description: >-
      Drive a live subscription · read it, change its plan, end it.
      Subscriptions are opened by a checkout session, not by this API.
  - name: Discount Codes
    description: Promo codes, redeemed at checkout.
  - name: Crypto
    description: >-
      The headless rail · quote, charge, and settle on-chain from inside your
      own site. No card data is involved, so none of the constraints that keep
      card collection on a Suby page apply here.
  - name: Customers
    description: First-class customer records with billing address.
  - name: Payment Methods
    description: >-
      Read and detach the cards a customer has stored. They are created by a
      checkout session (`savePaymentMethod`, or `mode=setup`) · the only place a
      card is collected.
  - name: Licence Key
    description: >-
      The licence server · validate a key, take a seat, free one. Authenticated
      with your API key like everything else, and scoped to the licences you
      issued, so your backend relays the check rather than your customer's
      software calling it directly.
paths:
  /v3/crypto/assets:
    get:
      tags:
        - Crypto
      summary: Chains and tokens this account accepts
      description: >
        Scoped to the caller, not the global catalogue. A headless integration
        built

        off the full catalogue offers assets the merchant never enabled, and the

        payer only finds out when the charge is refused.


        Tokens come nested under their chain. A chain's name, icon and payable

        `modes` are facts about the CHAIN, so they are stated once per chain

        rather than repeated on every token · the payload grows with the number

        of chains, not with the catalogue.


        `modes` says how a chain's tokens can actually be paid. Bitcoin is

        deposit-only · it has no contracts to sign against · so a UI that
        renders

        a "connect wallet" button on it builds a flow the API refuses.


        SANDBOX returns testnet chains, LIVE mainnet: a sandbox integration is

        never handed a mainnet address to send real funds to.
      operationId: listCryptoAssets
      parameters:
        - name: chainId
          in: query
          description: Restrict to one chain. Omit for everything the account accepts.
          schema:
            type: integer
            example: 8453
      responses:
        '200':
          description: Accepted assets
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/SuccessEnvelope'
                  - properties:
                      data:
                        type: object
                        properties:
                          chains:
                            type: array
                            items:
                              $ref: '#/components/schemas/CryptoChainAssets'
        '401':
          $ref: '#/components/responses/Unauthorized'
components:
  schemas:
    SuccessEnvelope:
      type: object
      required:
        - success
        - data
      properties:
        success:
          type: boolean
          example: true
        message:
          type: string
        data:
          description: Endpoint-specific payload.
    CryptoChainAssets:
      type: object
      description: One chain and the tokens of it this account accepts. Never empty.
      properties:
        chainId:
          type: integer
          example: 8453
          description: The on-chain id · what you send back as `chainId`.
        name:
          type: string
          example: Base
        isEvm:
          type: boolean
          description: EVM chains share one wallet adapter; Solana and Bitcoin do not.
        logoUrl:
          type: string
          nullable: true
        modes:
          type: array
          description: >-
            How THIS CHAIN's tokens can be paid. Bitcoin is `qr_deposit` only ·
            no contracts to sign against.
          items:
            type: string
            enum:
              - qr_deposit
              - wallet_connect
        assets:
          type: array
          description: Stables first, then alphabetical.
          items:
            $ref: '#/components/schemas/CryptoAsset'
    CryptoAsset:
      type: object
      properties:
        asset:
          type: string
          example: USDC
          description: >-
            The ticker, and the public key for this token alongside the chain's
            `chainId`. Pass it back as `asset` on a quote or a charge.
        name:
          type: string
          example: USD Coin
        decimals:
          type: integer
          example: 6
        isStable:
          type: boolean
        isNative:
          type: boolean
          description: The chain's gas token (ETH on Base, SOL on Solana).
        logoUrl:
          type: string
          nullable: true
    Error:
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          example: false
        error:
          type: string
          description: Machine-readable error code.
          example: NOT_FOUND
        message:
          type: string
          example: Resource not found
        data:
          description: Optional error detail.
  responses:
    Unauthorized:
      description: Invalid or missing API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            success: false
            error: UNAUTHORIZED
            message: Invalid or missing API key
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-Suby-Api-Key
      description: Secret API key. `sk_live_…` (production) or `sk_sandbox_…` (sandbox).

````