# Get Fiat Currencies

GET https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies

Get all supported fiat currencies.

Reference: https://docs.transak.com/api/public/get-fiat-currencies

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: currencies-api
  version: 1.0.0
paths:
  /fiat/public/v1/currencies/fiat-currencies:
    get:
      operationId: get-fiat-currencies
      summary: Get Fiat Currencies
      description: Get all supported fiat currencies.
      tags:
        - ''
      parameters:
        - name: apiKey
          in: query
          description: Your API Key from the Transak dashboard.
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Fiat currencies fetched successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/get-fiat-currencies_Response_200'
servers:
  - url: https://api-stg.transak.com
components:
  schemas:
    FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItemsPaymentOptionsItems:
      type: object
      properties:
        name:
          type: string
          description: Display name of the payment method.
        id:
          type: string
          description: Unique payment method identifier.
        displayText:
          type: boolean
          description: Whether the payment method should be shown in UI.
        processingTime:
          type: string
          description: Estimated processing time.
        icon:
          type: string
          description: Icon URL for the payment method.
        limitCurrency:
          type: string
          description: Currency in which transaction limits are expressed.
        maxAmount:
          type: integer
          description: Maximum supported amount.
        minAmount:
          type: integer
          description: Minimum supported amount.
        isActive:
          type: boolean
          description: Whether the payment method is active.
        defaultAmount:
          type: integer
          description: Suggested default amount.
        isConverted:
          type: boolean
          description: Whether the amount is converted across currencies.
        isPayOutAllowed:
          type: boolean
          description: Whether payout is allowed via this method.
        minAmountForPayOut:
          type: integer
          description: Minimum payout amount.
        maxAmountForPayOut:
          type: integer
          description: Maximum payout amount.
        defaultAmountForPayOut:
          type: integer
          description: Suggested default payout amount.
        isNftAllowed:
          type: boolean
          description: Whether NFT purchases are allowed.
        isNonCustodial:
          type: boolean
          description: Whether the payment method is non-custodial.
        provider:
          type: string
          description: Payment provider identifier.
        displayMessage:
          type: string
          description: Optional status message shown for the payment method.
        isBillingAddressRequired:
          type: boolean
          description: Whether billing address is required.
        supportedCountryCode:
          type: array
          items:
            type: string
          description: Country codes supported by the payment method.
        visaPayoutCountries:
          type: array
          items:
            type: string
          description: Countries where Visa payouts are supported.
        mastercardPayoutCountries:
          type: array
          items:
            type: string
          description: Countries where Mastercard payouts are supported.
      title: >-
        FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItemsPaymentOptionsItems
    FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItems:
      type: object
      properties:
        symbol:
          type: string
          description: Fiat currency symbol. E.g. USD.
        name:
          type: string
          description: Display name of the fiat currency.
        isAllowed:
          type: boolean
          description: Whether the fiat currency is supported for buy transactions.
        supportingCountries:
          type: array
          items:
            type: string
          description: Countries that support the fiat currency.
        logoSymbol:
          type: string
          description: Country or region code used for the fiat logo.
        isPopular:
          type: boolean
          description: Whether the fiat currency is marked as popular.
        paymentOptions:
          type: array
          items:
            $ref: >-
              #/components/schemas/FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItemsPaymentOptionsItems
        roundOff:
          type: integer
          description: Number of decimal places used for rounding.
        isPayOutAllowed:
          type: boolean
          description: Whether the fiat currency supports off-ramp transactions.
        defaultCountryForNFT:
          type: string
          description: Default country used for NFT support.
        displayMessage:
          type: string
          description: Optional message shown when the fiat currency is unavailable.
        icon:
          type: string
          description: Icon or SVG markup representing the fiat currency.
      title: >-
        FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItems
    get-fiat-currencies_Response_200:
      type: object
      properties:
        response:
          type: array
          items:
            $ref: >-
              #/components/schemas/FiatPublicV1CurrenciesFiatCurrenciesGetResponsesContentApplicationJsonSchemaResponseItems
      title: get-fiat-currencies_Response_200

```

## SDK Code Examples

```python Success
import requests

url = "https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies"

response = requests.get(url)

print(response.json())
```

```javascript Success
const url = 'https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success
require 'uri'
require 'net/http'

url = URI("https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
```

```java Success
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies")
  .asString();
```

```php Success
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies');

echo $response->getBody();
```

```csharp Success
using RestSharp;

var client = new RestClient("https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-stg.transak.com/fiat/public/v1/currencies/fiat-currencies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```