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

# Send money to a debit card (USD, EUR, GBP)

> Pay USDC to initiate a push-to-card transfer. Specify the face value in the target currency (USD, EUR, or GBP); Laso computes the USDC cost using the current exchange rate plus a 4.8% fee (minimum fee of \$1.50/€1.50/£1.50 in the transfer currency), and that becomes the x402 price. Returns a `redemption_url` that must be opened to complete the transfer. The form requires sender name, debit card number, and cardholder name.

**Supported currencies:**
- `USD` — U.S. debit cards (U.S. bank accounts only)
- `EUR` — Eurozone debit cards
- `GBP` — U.K. debit cards

Laso cannot perform the transfer directly — the redemption URL must be visited and the debit card details entered manually (by the agent or a human).

**Fee:** 4.8%, with a minimum of 1.50 in the transfer currency (included in the USDC price, computed from the requested face value).



## OpenAPI

````yaml /api-reference/openapi.json get /get-push-to-card
openapi: 3.1.0
info:
  title: Laso Finance x402 API
  version: 1.0.0
  x-docs-revision: 63bdfe2f5409
  x-docs-manifest: https://laso.finance/.well-known/docs-version.json
  contact:
    email: agents+support@laso.finance
  x-guidance: >-
    Laso Finance is a payment-gated (x402) API that lets an AI agent spend USDC
    on real-world financial products: prepaid cards (U.S. and international),
    gift cards, push-to-card transfers to USD/EUR/GBP debit cards, and
    Venmo/PayPal payouts.


    Payment: every paid route is an x402 v2 endpoint. Call it with no payment
    header to receive a 402 challenge listing the accepted networks, then replay
    with a signed USDC payment. Both Base (eip155:8453) and Solana
    (solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp) are accepted on every paid route;
    the caller picks either chain.


    Identity: `GET /auth` is free and identity-only. Prove wallet ownership with
    a `SIGN-IN-WITH-X` (CAIP-122) header to receive a Firebase id_token, then
    send that token as a Bearer credential to the authenticated read routes
    (`get-card-data`, `get-account-balance`, `get-kyc-status`, etc.). Paid
    routes also return fresh auth credentials in their response, so a payment is
    never required just to obtain a token.


    Recommended flow: (1) `GET /auth` to establish identity, (2) call a paid
    route (e.g. `GET /get-card`) to purchase a product, paying USDC on Base or
    Solana, (3) poll the authenticated read routes with the returned Bearer
    token to fetch the resulting card/transfer details. Full machine-readable
    instructions live at https://laso.finance/SKILL.md.
  description: >-
    Payment-gated API for Laso Finance. All paywalled routes use the x402
    protocol — the caller includes a USDC payment header on Base (eip155:8453)
    or Solana (solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp) and the server verifies
    payment before processing. Free routes require no payment header.


    ## Getting started


    To set up a wallet for making x402 payments, choose a provider:


    - **Locus** (default): https://paywithlocus.com/SKILL.md

    - **Sponge**: https://wallet.paysponge.com/skill.md — automatic x402 service
    discovery

    - **Ampersend**: https://www.ampersend.ai/getting-started.md — self-custody
    on Base or Solana with dual-approval spending limits. Laso Finance is a
    default skill, so no manual endpoint registration is needed.


    ## How x402 works


    1. Call a paywalled endpoint without a payment header → receive a `402
    Payment Required` response containing payment details (price, recipient
    address, network).

    2. Construct an x402 payment header using the details from the 402 response.

    3. Replay the request with the payment header → the server verifies payment
    and processes the request.


    ## Authentication flow


    `GET /auth` is free: callers prove wallet ownership by sending a
    `SIGN-IN-WITH-X` header (CAIP-122 wallet signature). Paywalled routes
    (`/get-card`, `/order-gift-card`, `/get-push-to-card`, `/order-intl-card`)
    also return fresh auth credentials in their responses, so a payment is never
    required just to obtain a token.


    Most routes return auth credentials (`id_token`, `refresh_token`,
    `expires_in`). Use the `id_token` as a Bearer token to call authenticated
    Laso Finance endpoints like `/get-card-data`. When the `id_token` expires,
    use `POST /auth` with `grant_type: refresh_token` to get a new one.


    ## Important notes


    The `/get-card` USA prepaid card endpoint is U.S. only — issued in USD,
    usable at U.S.-based merchants only, and physical goods must ship to a U.S.
    address. For non-U.S. merchants or non-USD currencies, use `GET
    /order-intl-card` instead (international prepaid card, admin-fulfilled
    within 24 hours). All cards are intended for the caller's own use.


    For step-by-step instructions, read https://laso.finance/SKILL.md
servers:
  - url: https://laso.finance
    description: Production
security: []
paths:
  /get-push-to-card:
    get:
      summary: Send money to a debit card (USD, EUR, GBP)
      description: >-
        Pay USDC to initiate a push-to-card transfer. Specify the face value in
        the target currency (USD, EUR, or GBP); Laso computes the USDC cost
        using the current exchange rate plus a 4.8% fee (minimum fee of
        \$1.50/€1.50/£1.50 in the transfer currency), and that becomes the x402
        price. Returns a `redemption_url` that must be opened to complete the
        transfer. The form requires sender name, debit card number, and
        cardholder name.


        **Supported currencies:**

        - `USD` — U.S. debit cards (U.S. bank accounts only)

        - `EUR` — Eurozone debit cards

        - `GBP` — U.K. debit cards


        Laso cannot perform the transfer directly — the redemption URL must be
        visited and the debit card details entered manually (by the agent or a
        human).


        **Fee:** 4.8%, with a minimum of 1.50 in the transfer currency (included
        in the USDC price, computed from the requested face value).
      operationId: pushToCard
      parameters:
        - name: amount
          in: query
          required: true
          description: >-
            Face value to send to the debit card, denominated in the chosen
            `currency` (min 10, max 9,541.98). The x402 payment price is this
            face value converted to USD plus a 4.8% fee (minimum fee of 1.50 in
            the chosen currency).
          schema:
            type: number
            minimum: 10
            maximum: 9541.98
        - name: currency
          in: query
          required: false
          description: Target currency for the debit card transfer. Defaults to `USD`.
          schema:
            type: string
            enum:
              - USD
              - EUR
              - GBP
            default: USD
      responses:
        '200':
          description: >-
            Push-to-card transfer initiated. Open the redemption_url to enter
            debit card details.
          content:
            application/json:
              schema:
                type: object
                properties:
                  auth:
                    $ref: '#/components/schemas/AuthCredentials'
                  callable_base_url:
                    type: string
                    example: https://us-central1-kyc-ts.cloudfunctions.net
                  user_id:
                    type: string
                    description: The user's ID (lowercase wallet address)
                  success:
                    type: boolean
                  message:
                    type: string
                    example: >-
                      Push-to-card transfer initiated. Open the redemption_url
                      to enter your debit card details and complete the
                      transfer.
                  amount:
                    type: number
                    description: >-
                      The face value sent to the debit card, in the requested
                      `currency`
                  currency:
                    type: string
                    enum:
                      - USD
                      - EUR
                      - GBP
                    description: The target currency of the debit card transfer
                  redemption_url:
                    type: string
                    description: >-
                      URL to open and complete the push-to-card transfer. The
                      form requires: sender name, debit card number, and
                      cardholder name.
                  note:
                    type: string
                    description: >-
                      Important information about the currency's regional
                      restriction and required form fields
        '400':
          description: Invalid or missing amount, or no payer address
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error: 'currency must be USD, EUR, or GBP. Received: XYZ'
        '402':
          description: >-
            Payment required. No valid x402 payment header was included. The
            response body is an empty JSON object; the payment details (price,
            recipient address, network) are base64-encoded in the
            `PAYMENT-REQUIRED` response header. x402 client libraries handle
            this automatically. A **second** 402 on the paid retry means
            something different: the payment header verified but the transfer
            could not be settled on-chain. That response body is not empty and
            carries no `accepts` — it is the x402 settlement-failure shape
            `{"success": false, "errorReason": "...", "errorMessage": "..."}`,
            plus `x_laso_guidance` when a concrete next step applies.
            Distinguish the two by body: a challenge has `accepts`, a failure
            has `success: false`. The usual cause is an underfunded wallet, and
            the usual cause of that is the fee being charged **on top of**
            `amount` (a wallet holding exactly \$2,000 cannot send a \$2,000
            payment). Nothing is charged for a failed settlement, so retrying
            with a smaller amount is safe.
          content:
            application/json:
              schema:
                type: object
                example: {}
        '403':
          description: >-
            Account is frozen. The response includes a `frozen_message` field
            explaining why.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FrozenError'
              example:
                error: Account is frozen
                frozen_message: >-
                  Your account is frozen pending a compliance review. Contact
                  support@laso.finance.
components:
  schemas:
    AuthCredentials:
      type: object
      properties:
        id_token:
          type: string
          description: ID token — use as Bearer token for Laso Finance APIs
        refresh_token:
          type: string
          description: >-
            Use with POST /auth (grant_type=refresh_token) to get a new id_token
            when it expires
        expires_in:
          type: string
          description: Token lifetime in seconds
    Error:
      type: object
      properties:
        error:
          type: string
    FrozenError:
      type: object
      properties:
        error:
          type: string
          example: Account is frozen
        frozen_message:
          type: string
          description: Human-readable explanation of why the account is frozen

````