> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.walletstech.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.walletstech.com/_mcp/server.

# Get your configuration

POST https://api-demo.walletstech.com/config

What your api client is enabled for: every `assetId` it may use, and who pays the network fee on each.

There is **no request body** — no `userId`, no `assetId`. The answer is the same for every user you hold.

## Read this instead of hardcoding the asset table

Your api client may be enabled for only some of the assets in the [Asset IDs](/get-started/assets) table, and a call for one you are not enabled for is a `403`. This endpoint is the list that will not `403` — resolved against the running service, so an asset that is *limited* on your environment is absent here too rather than failing later with `400 Unknown assetId`.

It is also the list `/create`, `/extend` and `/addresses` filter their address maps to: a chain appears there while you have at least one enabled asset on it.

Call it at startup and cache it. It changes only when your operator changes your account, so poll it on the order of minutes if you poll it at all.

## Who pays the fee

`feePayer` says who covers the network fee on a transfer of that asset:

* `USER` — the fee comes out of the sending wallet. For a native asset it is taken from the `amount`; for a token it is paid in the chain's native coin, which the wallet must therefore hold.
* `PLATFORM` — you cover it, so your user can move the token without holding any of the chain's native coin.

The top-level `feePayer` is `PLATFORM` when at least one of your assets is, and `USER` when none are.

`feePayer` describes your arrangement, not a guarantee for the next transfer. A `PLATFORM` asset can still fall back to `USER` on an individual send. **`/fee` is the only quote** — call it before a transfer and show your user what it returns.

Reference: https://docs.walletstech.com/api-reference/configuration/get-configuration

## Authentication

- `Authorization` header (bearer token, required) — A 15-minute token from `/auth`. Required on every endpoint except `/auth`.

## Servers

- `https://api-demo.walletstech.com` (Sandbox. Develop and test here. Requires its own credentials., default)
- `https://api.walletstech.com` (Production — real funds, and transfers that cannot be reversed. Requires its own credentials.)

## Request

### Headers

- `X-Request-Id` (string, optional) — Correlation id. Generated if omitted, echoed on every response, and written to the audit log. **`/send` is the exception — there it is required, and it doubles as the idempotency key.**

## Response

### 200

OK

- `result` (object, required)
  - `feePayer` (enum, required) — Who covers the network fee on a transfer. - `USER` — the fee comes out of the sending wallet, the usual arrangement. - `PLATFORM` — your api client covers it, so your user can move the token without holding the chain's native coin.
    - Allowed values: `USER`, `PLATFORM`
  - `assets` (list of object, required) — Every asset your api client is enabled for, in catalog order.
    - `assetId` (enum, required) — Primary asset selector. An all-digit string (`"21"`) is accepted and normalised to an integer. - `1` — BITCOIN BTC (native, 8 decimals) - `2` — ETHEREUM ETH (native, 18 decimals) - `21` — ETHEREUM USDT (ERC20, 6 decimals) - `22` — ETHEREUM USDC (ERC20, 6 decimals) - `3` — BSC BNB (native, 18 decimals) - `31` — BSC USDT (BEP20, 18 decimals) - `32` — BSC USDC (BEP20, 18 decimals) - `4` — TRON TRX (native, 6 decimals) - `41` — TRON USDT (TRC20, 6 decimals) - `42` — TRON USDC (TRC20, 6 decimals) — not on every endpoint - `5` — POLYGON POL (native, 18 decimals) - `51` — POLYGON USDT (ERC20, 6 decimals) — not on every endpoint - `52` — POLYGON USDC (ERC20, 6 decimals) - `6` — SOLANA SOL (native, 9 decimals) - `61` — SOLANA USDT (SPL, 6 decimals) — not on every endpoint - `62` — SOLANA USDC (SPL, 6 decimals)
      - Allowed values: `1`, `2`, `21`, `22`, `3`, `31`, `32`, `4`, `41`, `42`, `5`, `51`, `52`, `6`, `61`, `62`
    - `chain` (enum, required)
      - Allowed values: `BITCOIN`, `ETHEREUM`, `BSC`, `TRON`, `POLYGON`, `SOLANA`
    - `symbol` (string, required) — The coin symbol, and the key to read this asset's entry out of `/prices`.
    - `kind` (enum, required) — `NATIVE` is the chain's own coin; `TOKEN` is a contract on it.
      - Allowed values: `NATIVE`, `TOKEN`
    - `decimals` (integer, required) — Decimal places this asset supports. An amount with more than this many is rejected.
    - `feePayer` (enum, required) — Who covers the network fee on a transfer. - `USER` — the fee comes out of the sending wallet, the usual arrangement. - `PLATFORM` — your api client covers it, so your user can move the token without holding the chain's native coin.
      - Allowed values: `USER`, `PLATFORM`
    - `standard` (string, optional) — The token standard. Present on a `TOKEN`, absent on a `NATIVE` asset.
- `requestId` (string, required) — Echo of the inbound `X-Request-Id`, or a generated one.

## Errors

### 401 Unauthorized Error

Unauthorized — no bearer token, or one that does not verify. Get a fresh access token from `/refresh` (or `/auth`) and replay the request.

- `message` (string, required) — Safe, client-facing message. Internal detail never leaks here.
- `error` (string, required) — The HTTP status code, as a string.
- `requestId` (string, required) — Echo of the inbound `X-Request-Id`, or a generated one.

## Examples

### USDT fees covered on Ethereum and Tron

**Response**

```json
{
  "result": {
    "feePayer": "PLATFORM",
    "assets": [
      {
        "assetId": 1,
        "chain": "BITCOIN",
        "symbol": "BTC",
        "kind": "NATIVE",
        "decimals": 8,
        "feePayer": "USER"
      },
      {
        "assetId": 2,
        "chain": "ETHEREUM",
        "symbol": "ETH",
        "kind": "NATIVE",
        "decimals": 18,
        "feePayer": "USER"
      },
      {
        "assetId": 21,
        "chain": "ETHEREUM",
        "symbol": "USDT",
        "kind": "TOKEN",
        "decimals": 6,
        "feePayer": "PLATFORM",
        "standard": "ERC20"
      },
      {
        "assetId": 4,
        "chain": "TRON",
        "symbol": "TRX",
        "kind": "NATIVE",
        "decimals": 6,
        "feePayer": "USER"
      },
      {
        "assetId": 41,
        "chain": "TRON",
        "symbol": "USDT",
        "kind": "TOKEN",
        "decimals": 6,
        "feePayer": "PLATFORM",
        "standard": "TRC20"
      }
    ]
  },
  "requestId": "b7a1f0c2-3d4e-4a5b-9c6d-7e8f90a1b2c3"
}
```

**SDK Code**

```python USDT fees covered on Ethereum and Tron
import requests

url = "https://api-demo.walletstech.com/config"

headers = {"Authorization": "Bearer <token>"}

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

print(response.json())
```

```javascript USDT fees covered on Ethereum and Tron
const url = 'https://api-demo.walletstech.com/config';
const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

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

```go USDT fees covered on Ethereum and Tron
package main

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

func main() {

	url := "https://api-demo.walletstech.com/config"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby USDT fees covered on Ethereum and Tron
require 'uri'
require 'net/http'

url = URI("https://api-demo.walletstech.com/config")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java USDT fees covered on Ethereum and Tron
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-demo.walletstech.com/config")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php USDT fees covered on Ethereum and Tron
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-demo.walletstech.com/config', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp USDT fees covered on Ethereum and Tron
using RestSharp;

var client = new RestClient("https://api-demo.walletstech.com/config");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift USDT fees covered on Ethereum and Tron
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-demo.walletstech.com/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### Every fee paid by the sending wallet

**Response**

```json
{
  "result": {
    "feePayer": "USER",
    "assets": [
      {
        "assetId": 1,
        "chain": "BITCOIN",
        "symbol": "BTC",
        "kind": "NATIVE",
        "decimals": 8,
        "feePayer": "USER"
      },
      {
        "assetId": 2,
        "chain": "ETHEREUM",
        "symbol": "ETH",
        "kind": "NATIVE",
        "decimals": 18,
        "feePayer": "USER"
      },
      {
        "assetId": 22,
        "chain": "ETHEREUM",
        "symbol": "USDC",
        "kind": "TOKEN",
        "decimals": 6,
        "feePayer": "USER",
        "standard": "ERC20"
      }
    ]
  },
  "requestId": "b7a1f0c2-3d4e-4a5b-9c6d-7e8f90a1b2c3"
}
```

**SDK Code**

```python Every fee paid by the sending wallet
import requests

url = "https://api-demo.walletstech.com/config"

headers = {"Authorization": "Bearer <token>"}

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

print(response.json())
```

```javascript Every fee paid by the sending wallet
const url = 'https://api-demo.walletstech.com/config';
const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

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

```go Every fee paid by the sending wallet
package main

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

func main() {

	url := "https://api-demo.walletstech.com/config"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Every fee paid by the sending wallet
require 'uri'
require 'net/http'

url = URI("https://api-demo.walletstech.com/config")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java Every fee paid by the sending wallet
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-demo.walletstech.com/config")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Every fee paid by the sending wallet
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-demo.walletstech.com/config', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Every fee paid by the sending wallet
using RestSharp;

var client = new RestClient("https://api-demo.walletstech.com/config");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Every fee paid by the sending wallet
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-demo.walletstech.com/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```