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

# Change the Account Currency

> Sets the Account Currency to `CHF`, `EUR`, `USD` or `GBP`. Requires the
**Owner** or **Admin** role.

The change is allowed **at any time**, also with money on the balance.
It decides where new credits land: a payment quoted before the change
is credited in the currency of its quote, payments quoted after it in
the new Account Currency. The balance in the previous currency stays in
that currency: it can be paid out in it (`sourceCurrency` on the payout
request) or [converted](https://docs.qint.ch/api-reference/convert-balance)
into the new Account Currency. Funds are never converted by the change
itself.

A currency Qint does not offer, or has switched off, is refused with
`400` and `code: invalid_account_currency`. Re-sending the current
currency always succeeds.


> [!NOTE]
>
> A dashboard endpoint: it uses the signed-in dashboard session, not an API key, and requires the Owner or Admin role. The currency can change at any time; a balance in the previous currency stays payable in it and can be [converted](/api-reference/convert-balance.md). See [settlement and your Account Currency](/guides/settlement.md#choosing-your-account-currency).

| HTTP | `code` | When |
| - | - | - |
| 400 | `invalid_account_currency` | The currency is not one of CHF, EUR, USD and GBP, or Qint has switched it off. |


## OpenAPI

````yaml openapi.yaml PUT /api/v1/merchant/account-currency
openapi: 3.1.0
info:
  title: Qint Merchant API
  version: '1.1'
  description: >
    The Qint merchant API is a server-to-server API for creating and reading

    **payment intents**. You create an intent, redirect the buyer to the
    returned

    `checkoutUrl` (Qint's hosted checkout at `checkout.qint.ch`), and get
    notified

    of status changes via [webhooks](https://docs.qint.ch/webhooks/overview).


    ### Authentication

    Every request is authenticated with a Qint-issued API key

    (`qk_live_` + 32 alphanumeric characters), sent either as

    `Authorization: Bearer qk_live_…` or as an `X-Api-Key: qk_live_…` header.

    Keys carry **Read** and/or **Write** scopes: creating intents requires

    Write, reading them requires Read. The merchant account must be approved

    before the API accepts requests.


    ### Errors

    Errors are returned as RFC 7807 `application/problem+json` documents with

    `title`, `status` and `detail` fields.


    ### Rate limits

    The merchant API is rate limited. When a limit is exceeded the API responds

    with `429 Too Many Requests` — back off and retry. Intent creation is

    retry-safe: the required `idempotencyKey` makes a retried request return

    the original intent instead of creating a duplicate.


    ### Settlement

    Every payment is credited to the merchant's balance in its **Account

    Currency** (CHF, EUR, USD or GBP; CHF by default) at the rate fixed when

    the buyer is quoted. Since 20 October 2026 a payment intent reports the

    credit as `creditAmount`, `creditCurrency` and `creditRate`; the former

    stablecoin fields `creditUsdt` and `creditAsset` are no longer returned,

    and `creditRate` changed meaning. See

    [the breaking change
    note](https://docs.qint.ch/api-reference/introduction#breaking-change-20-october-2026).


    ### Dashboard endpoints

    The endpoints tagged **Dashboard** serve the Qint dashboard. They

    authenticate with the dashboard's signed-in session, not with an API key,

    and are documented so that the balance, balance conversion and Account

    Currency rules are described in one place.
  contact:
    name: Qint support
    email: support@qint.ch
    url: https://qint.ch
servers:
  - url: https://api.qint.ch
    description: Production
security:
  - bearerAuth: []
  - apiKeyHeader: []
tags:
  - name: Payment intents
    description: Create standalone payments and read their status.
  - name: Currencies
    description: Which fiat currencies Qint currently offers for new payments.
  - name: Dashboard
    description: >
      The merchant balance, conversions of a previous-currency balance and the
      Account Currency, as used by the Qint dashboard. Signed-in dashboard
      session only; API keys are not accepted.
paths:
  /api/v1/merchant/account-currency:
    put:
      tags:
        - Dashboard
      summary: Change the Account Currency
      description: >
        Sets the Account Currency to `CHF`, `EUR`, `USD` or `GBP`. Requires the

        **Owner** or **Admin** role.


        The change is allowed **at any time**, also with money on the balance.

        It decides where new credits land: a payment quoted before the change

        is credited in the currency of its quote, payments quoted after it in

        the new Account Currency. The balance in the previous currency stays in

        that currency: it can be paid out in it (`sourceCurrency` on the payout

        request) or
        [converted](https://docs.qint.ch/api-reference/convert-balance)

        into the new Account Currency. Funds are never converted by the change

        itself.


        A currency Qint does not offer, or has switched off, is refused with

        `400` and `code: invalid_account_currency`. Re-sending the current

        currency always succeeds.
      operationId: setAccountCurrency
      parameters:
        - $ref: '#/components/parameters/MerchantIdHeader'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AccountCurrencyRequest'
            example:
              currency: EUR
      responses:
        '200':
          description: The Account Currency after the change.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AccountCurrencySettings'
        '400':
          description: 'The currency is not offered (`code: invalid_account_currency`).'
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/Problem'
              example:
                title: An error occurred while processing your request.
                status: 400
                detail: >-
                  GBP is currently disabled on Qint. accountCurrency must be one
                  of: CHF, EUR, USD.
                code: invalid_account_currency
        '401':
          $ref: '#/components/responses/NotSignedIn'
        '403':
          $ref: '#/components/responses/NoMerchantAccess'
        '404':
          description: Merchant not found.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/Problem'
      security:
        - dashboardSession: []
components:
  parameters:
    MerchantIdHeader:
      name: X-Merchant-Id
      in: header
      required: false
      description: >
        The merchant account to act on, for users with access to more than one.
        Not needed when the user belongs to a single merchant account.
      schema:
        type: string
        format: uuid
  schemas:
    AccountCurrencyRequest:
      type: object
      required:
        - currency
      properties:
        currency:
          $ref: '#/components/schemas/AccountCurrency'
      additionalProperties: false
    AccountCurrencySettings:
      type: object
      required:
        - currency
        - changeable
        - currencies
      properties:
        currency:
          $ref: '#/components/schemas/AccountCurrency'
        setBy:
          type:
            - string
            - 'null'
          enum:
            - merchant
            - staff
            - null
          description: Who chose it; `null` while it is the CHF default.
        setAt:
          type:
            - string
            - 'null'
          format: date-time
        changeable:
          type: boolean
          description: >-
            Always `true`; the Account Currency can be changed at any time. Kept
            for compatibility.
        changeBlocker:
          type:
            - string
            - 'null'
          description: Always `null`. Kept for compatibility.
        currencies:
          type: array
          items:
            $ref: '#/components/schemas/AccountCurrency'
          description: The codes that can be chosen now.
      example:
        currency: EUR
        setBy: merchant
        setAt: '2026-10-20T13:05:00Z'
        changeable: true
        changeBlocker: null
        currencies:
          - CHF
          - EUR
          - USD
          - GBP
    Problem:
      type: object
      description: RFC 7807 problem details (`application/problem+json`).
      properties:
        type:
          type: string
          description: A URI reference identifying the problem type.
        title:
          type: string
          description: Short human-readable summary.
        status:
          type: integer
          description: The HTTP status code.
        detail:
          type: string
          description: Human-readable explanation of this occurrence.
        traceId:
          type: string
          description: Request correlation id — include it in support requests.
        code:
          type: string
          description: >
            Machine-readable error code: `amount_out_of_range`,
            `terms_acceptance_required` or `rate_unavailable` on the merchant
            API; `invalid_account_currency` on the Account Currency endpoint;
            `invalid_conversion`, `convert_same_currency`, `insufficient_funds`,
            `idempotency_key_reused`, `account_currency_changed` or
            `rate_unavailable` on the balance conversion endpoints. Absent on
            most errors, including a disabled currency, so fall back to `status`
            and `detail`.
        minChf:
          type: number
          description: Only with `amount_out_of_range` — the minimum payment in CHF.
        maxChf:
          type: number
          description: >-
            Only with `amount_out_of_range` — your effective maximum payment in
            CHF.
        amountChf:
          type: number
          description: >-
            Only with `amount_out_of_range` — the CHF equivalent of the
            submitted amount.
      example:
        type: https://tools.ietf.org/html/rfc9110#section-15.5.1
        title: An error occurred while processing your request.
        status: 400
        detail: 'currency must be one of: CHF, EUR, USD, GBP.'
        traceId: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00
    AccountCurrency:
      type: string
      enum:
        - CHF
        - EUR
        - USD
        - GBP
      description: >
        The fiat currency new payments are credited in (CHF unless the merchant
        chooses otherwise). It can change at any time; a balance in a previous
        Account Currency stays in that currency. Every payment is credited in
        the Account Currency of its quote, at the rate fixed when the buyer was
        quoted.
  responses:
    NotSignedIn:
      description: No signed-in dashboard session.
    NoMerchantAccess:
      description: >
        The signed-in user is not a member of this merchant account, or (for a
        change) lacks the required role.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >
        `Authorization: Bearer qk_live_…` — a Qint API key created in the
        dashboard under Developers → API keys.
    apiKeyHeader:
      type: apiKey
      in: header
      name: X-Api-Key
      description: >
        Alternative to the Authorization header — send the same `qk_live_…` key
        as `X-Api-Key`.
    dashboardSession:
      type: apiKey
      in: cookie
      name: qint_session
      description: >
        The signed-in session of the Qint dashboard (dashboard.qint.ch). Only
        the Dashboard endpoints use it; API keys are not accepted there.

````

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