# Get Capabilities

GET https://api-stg.transak.com/ledger/v1/capabilities

Fetch the supported fiat currencies together with their supported countries,
payment methods, and transaction limits.

Different payment methods can have different transaction limits for the same
fiat currency, so this endpoint should be used to build the available sell
options shown to the user.

Reference: https://docs.transak.com/api/ledger-off-ramp/get-capabilities

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: ledger-off-ramp-api
  version: 1.0.0
paths:
  /capabilities:
    get:
      operationId: get-capabilities
      summary: Get Capabilities
      description: >-
        Fetch the supported fiat currencies together with their supported
        countries,

        payment methods, and transaction limits.


        Different payment methods can have different transaction limits for the
        same

        fiat currency, so this endpoint should be used to build the available
        sell

        options shown to the user.
      tags:
        - ''
      parameters:
        - name: x-api-key
          in: header
          description: Transak API key available from the Transak Dashboard.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Capabilities fetched successfully.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CapabilitiesResponse'
        '400':
          description: Missing or invalid request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Internal server error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
servers:
  - url: https://api-stg.transak.com/ledger/v1
  - url: https://api.transak.com/ledger/v1
components:
  schemas:
    CryptoCurrencyCapability:
      type: object
      properties:
        id:
          type: string
        minAmount:
          type: number
          format: double
        maxAmount:
          type: number
          format: double
      required:
        - id
        - minAmount
        - maxAmount
      title: CryptoCurrencyCapability
    FiatCurrencyCapability:
      type: object
      properties:
        fiat:
          type: string
      required:
        - fiat
      title: FiatCurrencyCapability
    MinMaxRestriction:
      type: object
      properties:
        fiat:
          type: string
        minAmount:
          type: number
          format: double
        maxAmount:
          type: number
          format: double
      required:
        - fiat
        - minAmount
        - maxAmount
      title: MinMaxRestriction
    PaymentMethodCapability:
      type: object
      properties:
        name:
          type: string
        minMaxRestrictions:
          type: array
          items:
            $ref: '#/components/schemas/MinMaxRestriction'
      required:
        - name
        - minMaxRestrictions
      title: PaymentMethodCapability
    CountryCapability:
      type: object
      properties:
        country:
          type: string
          description: ISO 3166-1 alpha-2 country code.
        paymentMethods:
          type: array
          items:
            $ref: '#/components/schemas/PaymentMethodCapability'
      required:
        - country
        - paymentMethods
      title: CountryCapability
    CapabilitiesResponse:
      type: object
      properties:
        cryptoCurrencyCapabilities:
          type: array
          items:
            $ref: '#/components/schemas/CryptoCurrencyCapability'
        fiatCurrencyCapabilities:
          type: array
          items:
            $ref: '#/components/schemas/FiatCurrencyCapability'
        countriesCapabilities:
          type: array
          items:
            $ref: '#/components/schemas/CountryCapability'
      required:
        - cryptoCurrencyCapabilities
        - fiatCurrencyCapabilities
        - countriesCapabilities
      title: CapabilitiesResponse
    ErrorResponseError:
      type: object
      properties:
        messageKey:
          type: string
        message:
          type: string
      required:
        - messageKey
        - message
      title: ErrorResponseError
    ErrorResponse:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/ErrorResponseError'
      required:
        - error
      title: ErrorResponse
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: Transak API key available from the Transak Dashboard.

```

## SDK Code Examples

```python success
import requests

url = "https://api-stg.transak.com/ledger/v1/capabilities"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript success
const url = 'https://api-stg.transak.com/ledger/v1/capabilities';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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/ledger/v1/capabilities"

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

	req.Header.Add("x-api-key", "<apiKey>")

	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/ledger/v1/capabilities")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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/ledger/v1/capabilities")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-stg.transak.com/ledger/v1/capabilities', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp success
using RestSharp;

var client = new RestClient("https://api-stg.transak.com/ledger/v1/capabilities");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift success
import Foundation

let headers = ["x-api-key": "<apiKey>"]

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

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()
```