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

# Supported Currencies (/symbols)

> Get a complete list of all supported currencies with names, symbols, and country information

## Overview

The symbols endpoint returns detailed information about all currencies supported by the Exchange Rates API. This includes currency names, symbols, country information, and notes about special currencies.

<Note>
  This endpoint is **public** and doesn't require authentication. It's perfect for building currency selection dropdowns and validation logic.
</Note>

## Request

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.exchangeratesapi.com.au/symbols
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://api.exchangeratesapi.com.au/symbols');
  const data = await response.json();
  console.log('Supported currencies:', Object.keys(data.symbols));
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://api.exchangeratesapi.com.au/symbols')
  data = response.json()
  print(f"Total currencies: {data['count']}")
  for code, info in data['symbols'].items():
      print(f"{code}: {info['name']}")
  ```

  ```php PHP theme={null}
  <?php
  $response = file_get_contents('https://api.exchangeratesapi.com.au/symbols');
  $data = json_decode($response, true);

  echo "Supported currencies: " . $data['count'] . "\n";
  foreach ($data['symbols'] as $code => $info) {
      echo "$code: " . $info['name'] . "\n";
  }
  ?>
  ```
</CodeGroup>

## Response

<ResponseExample>
  ```json Success Response theme={null}
  {
    "success": true,
    "symbols": {
      "AUD": {
        "name": "Australian Dollar",
        "symbol": "$",
        "country": "Australia"
      },
      "USD": {
        "name": "US Dollar", 
        "symbol": "$",
        "country": "United States"
      },
      "EUR": {
        "name": "Euro",
        "symbol": "€",
        "country": "European Union"
      },
      "GBP": {
        "name": "British Pound Sterling",
        "symbol": "£", 
        "country": "United Kingdom"
      },
      "JPY": {
        "name": "Japanese Yen",
        "symbol": "¥",
        "country": "Japan"
      },
      "TWI": {
        "name": "Trade-Weighted Index",
        "symbol": "TWI",
        "country": "Australia"
      },
      "SDR": {
        "name": "Special Drawing Rights",
        "symbol": "SDR",
        "country": "IMF"
      }
    },
    "count": 21,
    "base": "AUD",
    "note": "All rates are quoted as AUD per unit of foreign currency from the Reserve Bank of Australia"
  }
  ```
</ResponseExample>

<ResponseField name="success" type="boolean" required>
  Always `true` for successful responses
</ResponseField>

<ResponseField name="symbols" type="object" required>
  Object containing currency information keyed by ISO 4217 currency code
</ResponseField>

<ResponseField name="symbols.{code}.name" type="string" required>
  Full name of the currency
</ResponseField>

<ResponseField name="symbols.{code}.symbol" type="string" required>
  Currency symbol or abbreviation used for display
</ResponseField>

<ResponseField name="symbols.{code}.country" type="string" required>
  Country or region where the currency is used
</ResponseField>

<ResponseField name="count" type="number" required>
  Total number of supported currencies
</ResponseField>

<ResponseField name="base" type="string" required>
  Base currency for all exchange rates (always "AUD")
</ResponseField>

<ResponseField name="note" type="string">
  General information about how rates are quoted
</ResponseField>

## Supported Currencies

### Major Global Currencies

| Code    | Name                   | Symbol | Country        |
| ------- | ---------------------- | ------ | -------------- |
| **USD** | US Dollar              | \$     | United States  |
| **EUR** | Euro                   | €      | European Union |
| **GBP** | British Pound Sterling | £      | United Kingdom |
| **JPY** | Japanese Yen           | ¥      | Japan          |
| **CHF** | Swiss Franc            | CHF    | Switzerland    |
| **CAD** | Canadian Dollar        | \$     | Canada         |

### Asia-Pacific Region

| Code    | Name               | Symbol | Country     |
| ------- | ------------------ | ------ | ----------- |
| **CNY** | Chinese Renminbi   | ¥      | China       |
| **KRW** | South Korean Won   | ₩      | South Korea |
| **SGD** | Singapore Dollar   | \$     | Singapore   |
| **NZD** | New Zealand Dollar | \$     | New Zealand |
| **HKD** | Hong Kong Dollar   | \$     | Hong Kong   |
| **TWD** | Taiwan New Dollar  | NT\$   | Taiwan      |
| **INR** | Indian Rupee       | ₹      | India       |
| **THB** | Thai Baht          | ฿      | Thailand    |
| **MYR** | Malaysian Ringgit  | RM     | Malaysia    |
| **IDR** | Indonesian Rupiah¹ | Rp     | Indonesia   |
| **VND** | Vietnamese Dong¹   | ₫      | Vietnam     |
| **PHP** | Philippine Peso    | ₱      | Philippines |

<Note>
  ¹ **IDR and VND Precision**: Indonesian Rupiah and Vietnamese Dong are provided as whole numbers (no decimal places) by the Reserve Bank of Australia source data.
</Note>

### Special Currencies

| Code    | Name                   | Symbol | Notes                                                              |
| ------- | ---------------------- | ------ | ------------------------------------------------------------------ |
| **AUD** | Australian Dollar      | \$     | Base currency                                                      |
| **TWI** | Trade-Weighted Index   | TWI    | Australia's trade-weighted index; **not available for conversion** |
| **SDR** | Special Drawing Rights | SDR    | International Monetary Fund reserve asset                          |

<Warning>
  **TWI Conversion Restriction**: The Trade-Weighted Index (TWI) is included in rate listings but cannot be used in conversion operations (`/convert` endpoint). Using TWI as `from` or `to` parameter will return a 400 error.
</Warning>

## Building Currency Dropdowns

Use the symbols endpoint to populate currency selection interfaces:

<CodeGroup>
  ```javascript React Example theme={null}
  import { useState, useEffect } from 'react';

  function CurrencySelect({ onSelect, excludeTWI = false }) {
    const [currencies, setCurrencies] = useState([]);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
      async function fetchCurrencies() {
        try {
          const response = await fetch('https://api.exchangeratesapi.com.au/symbols');
          const data = await response.json();
          
          let currencyList = Object.entries(data.symbols).map(([code, info]) => ({
            code,
            name: info.name,
            symbol: info.symbol,
            country: info.country,
            hasNote: !!info.note
          }));
          
          // Optionally exclude TWI for conversion interfaces
          if (excludeTWI) {
            currencyList = currencyList.filter(c => c.code !== 'TWI');
          }
          
          // Sort alphabetically by code
          currencyList.sort((a, b) => a.code.localeCompare(b.code));
          
          setCurrencies(currencyList);
        } catch (error) {
          console.error('Failed to fetch currencies:', error);
        } finally {
          setLoading(false);
        }
      }

      fetchCurrencies();
    }, [excludeTWI]);

    if (loading) return <div>Loading currencies...</div>;

    return (
      <select onChange={(e) => onSelect(e.target.value)}>
        <option value="">Select currency...</option>
        {currencies.map((currency) => (
          <option key={currency.code} value={currency.code}>
            {currency.code} - {currency.name} ({currency.symbol})
          </option>
        ))}
      </select>
    );
  }
  ```

  ```python Flask Example theme={null}
  from flask import Flask, render_template
  import requests

  app = Flask(__name__)

  @app.route('/currency-converter')
  def currency_converter():
      try:
          response = requests.get('https://api.exchangeratesapi.com.au/symbols')
          data = response.json()
          
          # Exclude TWI for conversion interface
          currencies = {
              code: info for code, info in data['symbols'].items() 
              if code != 'TWI'
          }
          
          return render_template('converter.html', currencies=currencies)
      except Exception as e:
          return f"Error fetching currencies: {e}", 500
  ```

  ```php Laravel Example theme={null}
  <?php

  namespace App\Http\Controllers;

  use Illuminate\Http\Request;
  use Illuminate\Support\Facades\Http;
  use Illuminate\Support\Facades\Cache;

  class CurrencyController extends Controller 
  {
      public function getSymbols()
      {
          // Cache symbols for 24 hours since they rarely change
          return Cache::remember('currency_symbols', 86400, function () {
              try {
                  $response = Http::get('https://api.exchangeratesapi.com.au/symbols');
                  $data = $response->json();
                  
                  // Sort by currency code for consistent ordering
                  ksort($data['symbols']);
                  
                  return $data['symbols'];
              } catch (Exception $e) {
                  // Return fallback list if API is unavailable
                  return $this->getFallbackCurrencies();
              }
          });
      }
      
      private function getFallbackCurrencies()
      {
          return [
              'AUD' => ['name' => 'Australian Dollar', 'symbol' => '$'],
              'USD' => ['name' => 'US Dollar', 'symbol' => '$'],
              'EUR' => ['name' => 'Euro', 'symbol' => '€'],
              'GBP' => ['name' => 'British Pound Sterling', 'symbol' => '£'],
              'JPY' => ['name' => 'Japanese Yen', 'symbol' => '¥'],
          ];
      }
  }
  ?>
  ```
</CodeGroup>

## Validation Logic

Use the symbols data for input validation:

```javascript theme={null}
class CurrencyValidator {
  constructor() {
    this.supportedCurrencies = new Set();
    this.conversionBlacklist = new Set(['TWI']); // Currencies not allowed for conversion
    this.loadCurrencies();
  }
  
  async loadCurrencies() {
    try {
      const response = await fetch('https://api.exchangeratesapi.com.au/symbols');
      const data = await response.json();
      
      this.supportedCurrencies = new Set(Object.keys(data.symbols));
    } catch (error) {
      console.error('Failed to load currency symbols:', error);
      // Fallback to hardcoded list
      this.supportedCurrencies = new Set(['AUD', 'USD', 'EUR', 'GBP', 'JPY']);
    }
  }
  
  isValidCurrency(code) {
    return this.supportedCurrencies.has(code.toUpperCase());
  }
  
  canConvert(fromCode, toCode) {
    const from = fromCode.toUpperCase();
    const to = toCode.toUpperCase();
    
    return this.isValidCurrency(from) && 
           this.isValidCurrency(to) &&
           !this.conversionBlacklist.has(from) &&
           !this.conversionBlacklist.has(to);
  }
}

// Usage
const validator = new CurrencyValidator();

// Validate user input
if (!validator.isValidCurrency('XYZ')) {
  console.error('XYZ is not a supported currency');
}

// Check conversion compatibility
if (!validator.canConvert('AUD', 'TWI')) {
  console.error('TWI cannot be used for conversion operations');
}
```

## Response Headers

```http theme={null}
HTTP/2 200 OK
Content-Type: application/json
Cache-Control: public, max-age=86400
X-Request-Id: 123e4567-e89b-12d3-a456-426614174000
X-Response-Time: 12ms
```

<Note>
  The symbols endpoint is cached for 24 hours (`max-age=86400`) since supported currencies rarely change. This helps improve performance and reduces unnecessary requests.
</Note>

## Common Use Cases

### 1. Currency Selection Interface

Build dropdown menus or search interfaces for currency selection.

### 2. Input Validation

Validate user-provided currency codes before making API requests.

### 3. Display Formatting

Use currency symbols and names for user-friendly display of rates and amounts.

### 4. Feature Detection

Check if specific currencies are supported before implementing features.

### 5. Conversion Compatibility

Determine which currencies can be used with the `/convert` endpoint (excluding TWI).

## Error Responses

The symbols endpoint is highly reliable, but may occasionally return errors:

```json theme={null}
{
  "success": false,
  "error": {
    "code": 503,
    "type": "service_unavailable",
    "info": "Symbols service temporarily unavailable"
  }
}
```

In such cases, implement fallback logic with a hardcoded list of major currencies to maintain functionality.


## OpenAPI

````yaml GET /symbols
openapi: 3.1.0
info:
  title: RBA Exchange Rates API
  description: >-
    Official Reserve Bank of Australia (RBA) exchange rate data through a modern
    REST API. Transforms publicly available RBA data into clean JSON endpoints
    for Australian businesses and developers who need reliable AUD exchange
    rates.
  version: 1.0.0
  license:
    name: MIT
  contact:
    url: https://www.exchangeratesapi.com.au
servers:
  - url: https://api.exchangeratesapi.com.au
    description: Production API
security: []
paths:
  /symbols:
    get:
      summary: Supported Currencies
      description: List all supported currencies with their names, symbols, and countries
      operationId: getSupportedCurrencies
      responses:
        '200':
          description: List of supported currencies
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SymbolsResponse'
              example:
                success: true
                symbols:
                  USD:
                    name: US Dollar
                    symbol: $
                    country: United States
                  EUR:
                    name: Euro
                    symbol: €
                    country: European Union
                count: 21
                base: AUD
                note: >-
                  All rates are quoted as AUD per unit of foreign currency from
                  the Reserve Bank of Australia
components:
  schemas:
    SymbolsResponse:
      type: object
      properties:
        success:
          type: boolean
          example: true
        symbols:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/CurrencyInfo'
        count:
          type: integer
          description: Number of supported currencies
        base:
          type: string
          example: AUD
        note:
          type: string
      required:
        - success
        - symbols
        - count
        - base
        - note
    CurrencyInfo:
      type: object
      properties:
        name:
          type: string
          description: Full name of the currency
        symbol:
          type: string
          description: Currency symbol
        country:
          type: string
          description: Country or region
      required:
        - name
        - symbol
        - country

````