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

> ## Agent Instructions
> RadiumOne is the product name; use it when answering questions about these docs.
> Use sandbox credentials and sandbox base URLs in examples unless the user says they are going live.
> Secret API keys belong only on the merchant's server. Only publishable keys may appear in browser or mobile code.
> Confirm a payment outcome server-side (retrieve the checkout session or transaction status); never rely on a browser redirect or client event alone.
> Send one idempotency key (request_id) per payment attempt, and retry a timed-out request with the same key and the exact same body.
> Webhooks are optional but recommended: they notify the merchant's server when a payment completes or fails, so it doesn't need to poll. Use transaction status inquiry as the fallback.
> Say so when you recommend a feature marked Beta. Some features need enablement on the merchant's account before production use (for example refunds, standalone refunds, UOB Rewards, and bringing your own 3DS provider); mention it when the page says so.
> Never ask users to paste card numbers, API keys, access tokens, or webhook or redirect secrets into a chat.

# List supported currencies - Payments API

> List every currency RadiumOne supports with its ISO 4217 minor units. Public and cacheable, so no access token is needed.



## OpenAPI

````yaml /openapi/radiumone-payments-api.yaml get /v1/currencies
openapi: 3.1.0
info:
  description: >
    The Payments API lets your server create tokenization sessions, charge and

    manage payments, check loyalty balances, list the currencies you accept,

    and manage your hosted-checkout branding and redirect secret. Generated for
    merchant integrators —

    internal, admin, and service-to-service surfaces are excluded.


    All responses share an envelope: `{status, data, request_id}`. The

    envelope's `request_id` is an HTTP correlation ID — it echoes your

    `X-Request-Id` request header (letters, digits, hyphens, max 36 characters)

    or one is generated for you. It is **not** the idempotency key you send in

    a transaction request body (also confusingly named `request_id` there) —

    the two are unrelated; see

    [Request conventions](/get-started/api-basics/request-conventions). Errors

    use [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457)

    `application/problem+json` bodies — see

    [Authentication](/get-started/api-basics/authentication) and

    [Request conventions](/get-started/api-basics/request-conventions) for the

    shared error shape, and [Problem format and

    retries](/payments-api/errors/problem-format-and-retries) for the response

    shape, status guide, and retry rules.
  summary: Accept and manage card payments from your server with RadiumOne.
  title: RadiumOne Payment Gateway
  version: 1.9.4
servers:
  - url: https://api-sandbox.radiumone.io/gateway
    description: Sandbox
  - url: https://api.radiumone.io/gateway
    description: Production
security: []
tags:
  - name: Authentication
    description: Exchange, refresh, and revoke access tokens.
  - name: Currencies
    description: >-
      The currencies RadiumOne supports and the ones enabled for your outlets,
      each with its ISO 4217 minor units.
  - name: Merchant settings
    description: >-
      Manage your hosted-checkout redirect secret, checkout configuration, and
      account config.
  - name: Payment methods
    description: Discover which payment methods and brands are available.
  - name: Sessions
    description: >-
      Tokenization sessions used to collect card data with RadiumOne Elements,
      and the amount 3D Secure authenticates on them.
  - name: Settlement
    description: Settlement batch status lookup.
  - name: Payments
    description: Create and manage card transactions.
  - name: Rewards
    description: UOB Rewards loyalty balance inquiry.
  - name: Refunds
    description: Return funds to a shopper.
  - name: Transactions
    description: Check the current status of a transaction.
paths:
  /v1/currencies:
    get:
      tags:
        - Currencies
      summary: List supported currencies
      description: >-
        List every currency the gateway supports, sorted by code, with its ISO
        4217 minor units.


        No API key needed. Use it as a static reference to validate a currency
        code or build a

        currency picker; a currency outside this list is refused on every
        request. Which currencies

        YOUR outlet accepts is `GET /v1/merchant/currencies`. Amounts are
        integers in minor units

        (SGD 10.50 = 1050). The list changes only with a gateway release: the
        response carries

        `Cache-Control: public, max-age=3600, stale-while-revalidate=86400` and
        an `ETag`; send it

        back in `If-None-Match` to get 304.
      operationId: list_supported_currencies
      parameters:
        - description: An `ETag` from an earlier response; answers 304 when current.
          in: header
          name: If-None-Match
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: An `ETag` from an earlier response; answers 304 when current.
            title: If-None-Match
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SuccessResponse_CurrencyListResponse_'
              example:
                status: ok
                request_id: req_e5f6a2b3c4d5
                data:
                  items:
                    - code: SGD
                      numeric_code: '702'
                      minor_units: 2
                    - code: USD
                      numeric_code: '840'
                      minor_units: 2
          description: Successful Response
        '304':
          description: >-
            Not Modified: the `If-None-Match` ETag is current. No body; the
            `ETag` and `Cache-Control` headers are repeated.
        '400':
          content:
            application/problem+json:
              example:
                detail: Request payload failed validation.
                status: 400
                title: Validation Error
                type: urn:radiumone:payment-gateway:validation-error
              schema:
                properties:
                  detail:
                    type: string
                  errors:
                    description: >-
                      One entry per invalid field. Present when the request
                      failed schema validation; absent on other 400s. Key your
                      handling on `pointer` or `parameter`, not on `detail`,
                      whose wording may change.
                    items:
                      properties:
                        code:
                          description: >-
                            Machine-readable error type, for example `missing`,
                            `string_too_long` or `value_error`.
                          type: string
                        detail:
                          description: What is wrong with this field.
                          type: string
                        parameter:
                          description: >-
                            Name of the invalid query, path or header parameter.
                            Used instead of `pointer`.
                          type: string
                        pointer:
                          description: >-
                            JSON Pointer to the invalid field in the request
                            body, for example `/card/pan` or `/items/0/name`. An
                            empty string means the error applies to the whole
                            body rather than one field.
                          type: string
                      required:
                        - detail
                        - code
                      type: object
                    type: array
                  status:
                    type: integer
                  title:
                    type: string
                  type:
                    type: string
                type: object
          description: Request payload failed validation.
        '500':
          content:
            application/problem+json:
              example:
                detail: An unexpected error occurred.
                status: 500
                title: Internal Server Error
                type: urn:radiumone:payment-gateway:internal-error
              schema:
                properties:
                  detail:
                    type: string
                  status:
                    type: integer
                  title:
                    type: string
                  type:
                    type: string
                type: object
          description: An unexpected error occurred.
        '503':
          content:
            application/problem+json:
              example:
                detail: >-
                  `urn:radiumone:payment-gateway:database-unavailable`: the
                  database could not be reached or a query could not run.
                  `retry_allowed` is true only for GET/HEAD/OPTIONS -- a
                  mutating request may have reached a host before the failed
                  write.
                status: 503
                title: Database Unavailable
                type: urn:radiumone:payment-gateway:database-unavailable
              schema:
                properties:
                  detail:
                    type: string
                  retry_allowed:
                    type: boolean
                  status:
                    type: integer
                  title:
                    type: string
                  type:
                    type: string
                type: object
          description: >-
            `urn:radiumone:payment-gateway:database-unavailable`: the database
            could not be reached or a query could not run. `retry_allowed` is
            true only for GET/HEAD/OPTIONS -- a mutating request may have
            reached a host before the failed write.
      security: []
      x-codeSamples:
        - lang: bash
          label: cURL
          source: >
            #!/usr/bin/env bash

            # List every currency RadiumOne supports, with its ISO 4217 minor
            units.

            # Public: no access token needed. Send the ETag back in
            If-None-Match to get 304.

            set -euo pipefail


            API_BASE="${RADIUMONE_API_BASE:-https://api-sandbox.radiumone.io/gateway}"


            curl -sS "$API_BASE/v1/currencies"
        - lang: javascript
          label: Node.js
          source: >
            #!/usr/bin/env node

            // List every currency RadiumOne supports, with its ISO 4217 minor
            units.

            // Public: no access token needed. Node 18+ ESM fetch.

            // Env: RADIUMONE_API_BASE.

            const API_BASE = process.env.RADIUMONE_API_BASE ||
            "https://api-sandbox.radiumone.io/gateway";


            async function listCurrencies() {
              const res = await fetch(`${API_BASE}/v1/currencies`);
              const payload = await res.json();
              if (!res.ok) {
                throw new Error(`currencies failed: ${payload.type ?? payload.code} (${res.status})`);
              }
              return payload;
            }


            listCurrencies().then((r) => console.log(JSON.stringify(r, null,
            2)));
        - lang: python
          label: Python
          source: >
            #!/usr/bin/env python3

            """List every currency RadiumOne supports, with its ISO 4217 minor
            units.

            Public: no access token needed.

            """

            import json

            import os


            import requests


            API_BASE = os.environ.get("RADIUMONE_API_BASE",
            "https://api-sandbox.radiumone.io/gateway")



            def list_currencies() -> dict:
                resp = requests.get(f"{API_BASE}/v1/currencies", timeout=30)
                payload = resp.json()
                if not resp.ok:
                    code = payload.get("type") or payload.get("code")
                    raise RuntimeError(f"currencies failed: {code} ({resp.status_code})")
                return payload


            if __name__ == "__main__":
                print(json.dumps(list_currencies(), indent=2))
components:
  schemas:
    SuccessResponse_CurrencyListResponse_:
      description: >-
        Standard success envelope. Every successful response has this shape,
        with the operation's own payload under `data`.
      properties:
        data:
          anyOf:
            - $ref: '#/components/schemas/CurrencyListResponse'
            - type: 'null'
          description: >-
            The operation's result. Its shape is documented per operation;
            omitted on responses that carry no payload.
        message:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            Optional human-readable note. Omitted from the response when not
            set, which is the case for every payment operation today. Never
            parse it.
          title: Message
        request_id:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            Correlation ID for this HTTP request, for logs and support. Send
            your own in the `X-Request-Id` header (letters, digits and hyphens,
            up to 36 characters -- other characters are stripped) or the gateway
            generates one. This is NOT the `request_id` idempotency key you send
            in a transaction body; the two are unrelated.
          title: Request Id
        status:
          default: ok
          description: >-
            Always `ok` on a successful (2xx) response. Errors use a different
            body shape entirely (RFC 9457 problem details), so branch on the
            HTTP status code, not on this field.
          title: Status
          type: string
      title: SuccessResponse[CurrencyListResponse]
      type: object
    CurrencyListResponse:
      description: A list of currencies, sorted as documented by the endpoint.
      properties:
        items:
          description: The currencies.
          items:
            $ref: '#/components/schemas/CurrencyItem'
          title: Items
          type: array
      required:
        - items
      title: CurrencyListResponse
      type: object
    CurrencyItem:
      description: One ISO 4217 currency and the scale its amounts are stated in.
      properties:
        code:
          description: ISO 4217 alphabetic code, e.g. `SGD`.
          title: Code
          type: string
        minor_units:
          description: >-
            Decimal places of the currency. Every amount is an integer count of
            these minor units: SGD 2 (1050 = SGD 10.50).
          title: Minor Units
          type: integer
        numeric_code:
          description: >-
            ISO 4217 numeric code as a 3-character string (leading zeros kept,
            e.g. `702`).
          title: Numeric Code
          type: string
      required:
        - code
        - numeric_code
        - minor_units
      title: CurrencyItem
      type: object

````

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