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

# Assets

> Use the Assets API to discover supported assets, check payment availability, and show market context before users deposit, withdraw, or trade.

## Overview

The Assets API is the catalog for assets available through Payward Services. Use it before a payment or trading flow to decide which assets to show, how much precision to accept, and whether deposits, withdrawals, or swaps are currently enabled.

The same responses also include display metadata and market data. Use this data to build asset pickers, payment setup screens, and price history views.

## Prerequisites

* Payward Services API credentials (see the [Authentication guide](/tabs/developer-documentation/get-started/authentication))
* Base URL: `https://api.services.payward.com`

## Asset discovery workflow

Use this flow when you build a screen that lets a user choose an asset, review its details, and continue into a deposit, withdrawal, or trade.

<Steps>
  <Step title="List available assets">
    Filter the catalog to assets enabled for the action you want to offer.

    `GET /v1/assets`
  </Step>

  <Step title="Inspect the selected asset">
    Fetch the asset again when the user selects it. Check current status, precision, logo, and quote-denominated market data.

    `GET /v1/assets/{asset_type}/{asset_symbol}`
  </Step>

  <Step title="Show price history">
    Fetch historical rates when you need a chart, recent trend, or change-over-time display.

    `GET /v1/assets/{asset_type}/{asset_symbol}/rates`
  </Step>

  <Step title="Continue to the user action">
    Use the selected `symbol` with the deposits, withdrawals, or trade endpoints.

    See [Deposits and withdrawals](/tabs/developer-documentation/payments/deposits-and-withdrawals).
  </Step>
</Steps>

<Note>
  Asset prices and rates are useful for display and discovery. Do not use them as executable trade quotes. Use the [Swap
  API](/tabs/developer-documentation/trade/swap) when you need a locked trading price.
</Note>

## Step 1: list available assets

Call `GET /v1/assets` to build the asset list for your UI. Filter by asset type and capability so users only see assets that support the action they are trying to complete.

<CodeGroup>
  ```python Python theme={null}
  def list_assets(page_token=None):
      endpoint = "/v1/assets"
      params = [
          # Repeat `type` to filter on several asset types at once.
          ("type", "crypto"),
          ("type", "stablecoin"),
          ("deposit", "true"),
          ("withdraw", "true"),
          ("quote_symbol", "USD"),
          ("quote_type", "fiat"),
          ("sort", "market_cap_rank"),
          ("sort_direction", "asc"),
      ]
      if page_token:
          params.append(("page_token", page_token))

      response = requests.get(
          f"{BASE_URL}{endpoint}",
          params=params,
      )
      return response.json()


  assets = list_assets()
  for asset in assets["data"]:
      print(asset["symbol"], asset["status"]["deposit"]["enabled"])
  ```

  ```javascript Javascript theme={null}
  async function listAssets(pageToken = null) {
    const endpoint = '/v1/assets';
    const params = new URLSearchParams();
    // Repeat `type` to filter on several asset types at once.
    params.append('type', 'crypto');
    params.append('type', 'stablecoin');
    params.set('deposit', 'true');
    params.set('withdraw', 'true');
    params.set('quote_symbol', 'USD');
    params.set('quote_type', 'fiat');
    params.set('sort', 'market_cap_rank');
    params.set('sort_direction', 'asc');
    if (pageToken) params.set('page_token', pageToken);

    const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
      method: 'GET',
    });

    return response.json();
  }

  const assets = await listAssets();
  for (const asset of assets.data) {
    console.log(asset.symbol, asset.status.deposit.enabled);
  }
  ```
</CodeGroup>

Use these fields from each asset:

| Field                                                       | How to use it                                     |
| ----------------------------------------------------------- | ------------------------------------------------- |
| `symbol` and `type`                                         | Identify the asset in later API calls.            |
| `name` and `logo`                                           | Display the asset in your picker.                 |
| `status.deposit.enabled`                                    | Show or hide deposit entry points.                |
| `status.withdraw.enabled`                                   | Show or hide withdrawal entry points.             |
| `status.swap_trading.enabled`                               | Show or hide trade entry points.                  |
| `status.swap_trading.disabled_against`                      | Prevent unsupported swap pairs.                   |
| `decimals.funding`                                          | Validate deposit and withdrawal amounts.          |
| `decimals.swap`                                             | Validate swap amounts.                            |
| `price`, `market_cap`, `volume`, and `price_change_percent` | Show market context in the requested quote asset. |

The list endpoint is cursor-paginated. If the response includes `next_page_token`, pass it as `page_token` to fetch the next page.

See the [List Assets API reference](/api-reference/assets/list-assets) for all filters, sort options, and response fields.

## Step 2: inspect the selected asset

Call `GET /v1/assets/{asset_type}/{asset_symbol}` when the user selects an asset. This gives you the same normalized shape as the list response, scoped to one asset.

<CodeGroup>
  ```python Python theme={null}
  def get_asset(asset_type, asset_symbol, quote_symbol="USD", quote_type="fiat"):
      endpoint = f"/v1/assets/{asset_type}/{asset_symbol}"
      params = {
          "quote_symbol": quote_symbol,
          "quote_type": quote_type,
      }
      response = requests.get(
          f"{BASE_URL}{endpoint}",
          params=params,
      )
      return response.json()


  btc = get_asset("crypto", "BTC")
  print(btc["data"]["status"]["withdraw"]["enabled"])
  ```

  ```javascript Javascript theme={null}
  async function getAsset(assetType, assetSymbol, quoteSymbol = 'USD', quoteType = 'fiat') {
    const endpoint = `/v1/assets/${assetType}/${assetSymbol}`;
    const params = new URLSearchParams({
      quote_symbol: quoteSymbol,
      quote_type: quoteType,
    });
    const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
      method: 'GET',
    });

    return response.json();
  }

  const btc = await getAsset('crypto', 'BTC');
  console.log(btc.data.status.withdraw.enabled);
  ```
</CodeGroup>

Before you continue:

* Check `status.deposit.enabled` before you create or show deposit addresses.
* Check `status.withdraw.enabled` before you list withdrawal methods or let a user save a withdrawal address.
* Use `decimals.funding` to format and validate payment amounts.
* Use `quote_symbol` and `quote_type` consistently so your UI does not mix valuations from different quote assets.

See the [Get Asset API reference](/api-reference/assets/get-asset) for the full response schema.

## Step 3: show price history

Call `GET /v1/assets/{asset_type}/{asset_symbol}/rates` when you need historical prices for a chart or trend display. Set the quote asset, time window, and interval explicitly.

<CodeGroup>
  ```python Python theme={null}
  def list_asset_rates(asset_type, asset_symbol, page_token=None):
      endpoint = f"/v1/assets/{asset_type}/{asset_symbol}/rates"
      params = {
          "quote_symbol": "USD",
          "quote_type": "fiat",
          "start_timestamp": "2026-04-21T00:00:00Z",
          "end_timestamp": "2026-04-26T23:59:59Z",
          "interval": "P1D",
      }
      if page_token:
          params["page_token"] = page_token

      response = requests.get(
          f"{BASE_URL}{endpoint}",
          params=params,
      )
      return response.json()


  rates = list_asset_rates("crypto", "BTC")
  for rate in rates["data"]:
      print(rate["timestamp"], rate["price"])
  ```

  ```javascript Javascript theme={null}
  async function listAssetRates(assetType, assetSymbol, pageToken = null) {
    const endpoint = `/v1/assets/${assetType}/${assetSymbol}/rates`;
    const params = new URLSearchParams({
      quote_symbol: 'USD',
      quote_type: 'fiat',
      start_timestamp: '2026-04-21T00:00:00Z',
      end_timestamp: '2026-04-26T23:59:59Z',
      interval: 'P1D',
    });
    if (pageToken) params.set('page_token', pageToken);

    const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
      method: 'GET',
    });

    return response.json();
  }

  const rates = await listAssetRates('crypto', 'BTC');
  for (const rate of rates.data) {
    console.log(rate.timestamp, rate.price);
  }
  ```
</CodeGroup>

Supported intervals include `PT1M`, `PT5M`, `PT15M`, `PT30M`, `PT60M`, `PT4H`, `P1D`, `P7D`, and `P15D`. Use the `next_page_token` from the response when you need more history.

See the [List Asset Rates API reference](/api-reference/assets/list-asset-rates) for all query parameters and pagination behavior.

## User-scoped asset views

Each endpoint above has a user-scoped variant under `/v1/users/{user_id}/assets`. These return the same asset shape, scoped to one user — reflecting that user's eligibility and any per-account restrictions on deposit, withdrawal, or trading.

Use the public endpoints to build a general catalog. Use the user-scoped variants when you already know which user the screen is for and want availability that matches that specific account. Pass the user's IIBAN as `user_id`:

* `GET /v1/users/{user_id}/assets`
* `GET /v1/users/{user_id}/assets/{asset_type}/{asset_symbol}`
* `GET /v1/users/{user_id}/assets/{asset_type}/{asset_symbol}/rates`

Query parameters, pagination, and response fields match their public counterparts.

## API reference

| Endpoint                                                       | Method | Description                                                                           |
| -------------------------------------------------------------- | ------ | ------------------------------------------------------------------------------------- |
| `/v1/assets`                                                   | GET    | List assets with filters for type, payment availability, and market data              |
| `/v1/assets/{asset_type}/{asset_symbol}`                       | GET    | Get metadata, payment availability, precision, and market data for one asset          |
| `/v1/assets/{asset_type}/{asset_symbol}/rates`                 | GET    | List historical rates for an asset in the requested quote asset                       |
| `/v1/users/{user_id}/assets`                                   | GET    | List assets scoped to a specific user, with that user's availability and restrictions |
| `/v1/users/{user_id}/assets/{asset_type}/{asset_symbol}`       | GET    | Get one asset scoped to a specific user                                               |
| `/v1/users/{user_id}/assets/{asset_type}/{asset_symbol}/rates` | GET    | List historical rates for an asset scoped to a specific user                          |