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

# Supported Tokens & Routes

> Relay currently supports multiple cross-chain routes across 69+ blockchain networks. This guide explains how to determine if a particular route and token pair are supported by Relay

export const SupportedRoutes = ({id}) => {
  const key = 'supported-routes-data';
  if (typeof window === "undefined") {
    return null;
  }
  if (typeof document === "undefined") {
    return null;
  }
  if (!window[key]) {
    window[key] = {
      fetching: false,
      data: null,
      observer: null
    };
  }
  if (!window[key].fetching) {
    const showLoading = () => {
      const rootElement = document.getElementById(id);
      if (!rootElement) {
        return;
      }
      rootElement.innerHTML = `<tr><td colspan="4" style="text-align: center; padding: 20px;">Loading...</td></tr>`;
    };
    const appendRoutes = data => {
      const rootElement = document.getElementById(id);
      if (!rootElement) {
        return;
      }
      const priorityChains = ['Ethereum', 'Base', 'Arbitrum', 'Optimism', 'BNB', 'Polygon', 'Solana'];
      const rows = data.slice().sort((a, b) => {
        const aIndex = priorityChains.indexOf(a.displayName);
        const bIndex = priorityChains.indexOf(b.displayName);
        if (aIndex !== -1 && bIndex !== -1) {
          return aIndex - bIndex;
        }
        if (aIndex !== -1) return -1;
        if (bIndex !== -1) return 1;
        return a.displayName.localeCompare(b.displayName);
      }).map(chain => {
        const solverCurrencies = chain.solverCurrencies ? chain.solverCurrencies.slice().sort((a, b) => {
          const priority = ['ETH', 'USDC', 'USDT'];
          const aIndex = priority.indexOf(a.symbol);
          const bIndex = priority.indexOf(b.symbol);
          if (aIndex !== -1 && bIndex !== -1) {
            return aIndex - bIndex;
          }
          if (aIndex !== -1) return -1;
          if (bIndex !== -1) return 1;
          return 0;
        }).map(c => c.symbol).join(', ') : '';
        const swapsSupported = chain.tokenSupport === 'All' ? 'true' : 'false';
        const gasTopUpSupported = chain.vmType === 'evm' && (chain.tokenSupport === "All" || chain.currency && chain.currency.supportsBridging === true);
        return `<tr key=${chain.id}>
          <td>${chain.displayName}</td>
          <td>${solverCurrencies}</td>
          <td>${swapsSupported}</td>
          <td>${gasTopUpSupported ? 'true' : 'false'}</td>
        </tr>`;
      });
      rootElement.innerHTML = `<div id="${id}-marker"></div>${rows.join("")}`;
      if (!window[key].observer) {
        let observer = new MutationObserver(function (mutations) {
          if (!document.getElementById(`${id}-marker`)) {
            appendRoutes(data);
          }
        });
        observer.observe(document.body, {
          childList: true,
          subtree: true
        });
        window[key].observer = observer;
      }
    };
    const fetchChains = async () => {
      try {
        if (window[key].fetching) return;
        window[key].fetching = true;
        window[key].data = null;
        showLoading();
        const response = await fetch("https://api.relay.link/chains");
        const data = await response.json();
        window[key].fetching = false;
        window[key].data = data.chains;
        appendRoutes(data.chains);
      } catch (e) {
        console.error('Error fetching chains:', e);
        window[key].fetching = false;
        window[key].data = false;
      }
    };
    if (window[key].data) {
      appendRoutes(window[key].data);
    } else {
      showLoading();
      fetchChains();
    }
  }
  return <table style={{
    width: "100%"
  }} className="relay-table">
<thead style={{
    borderBottom: "1px solid rgb(227 226 230)",
    paddingBottom: 5,
    width: "100%",
    fontSize: 16
  }}>
<tr style={{
    textAlign: "left"
  }}>
<th>Chain Name</th>
<th>Solver Currencies (supported natively)</th>
<th>Swaps Supported</th>
<th>Gas Top Up Supported</th>
</tr>
</thead>
<tbody id={id}></tbody>
</table>;
};

## Solver Currencies and Swap Support

<SupportedRoutes id="supportedRoutes" />

## How to check if a route is supported?

To determine if a route is supported (also referred to as whether a token is supported for bridging), use the [Chains API](https://api.relay.link/chains) to check for an available route between a given token pair.

```bash theme={null}
curl -X GET "https://api.relay.link/chains"
```

The response will return a list of chains, each containing supported token pairs. To verify if a route is supported, follow these steps:

### Step 1: Check Token Support Level

Look for the `tokenSupport` field in the response for a given chain:

* If `tokenSupport` is `"All"`, then routes involving this chain as either the origin or destination are supported for tokens where Solver or DEX liquidity is available.
* If `tokenSupport` is `"Limited"`, proceed to step 2.

### Step 2: Check Individual Token Support

If `tokenSupport` is `"Limited"`, check the `erc20Currencies` and `currency` fields in the response. These fields contain token objects with metadata indicating whether a token supports bridging.

### Step 3: Verify Bridging Support

Locate the `supportsBridging` field in the token object:

* If `supportsBridging` is `true`, the token is supported for bridging.
* If `supportsBridging` is `false` or if the token pair is not listed in `erc20Currencies` or `currency`, then the route is not supported.

## Examples of Supported and Limited Token Routes

### Example: All Tokens Supported

```json expandable theme={null}
{
  "chains": [
        {
            "id": 10,
            "name": "optimism",
            "displayName": "Optimism",
            "tokenSupport": "All",
            "currency": {
                "id": "eth",
                "symbol": "ETH",
                "name": "Ether",
                "address": "0x0000000000000000000000000000000000000000",
                "decimals": 18,
                "supportsBridging": true
            },
            "erc20Currencies": [
                {
                    "id": "wbtc",
                    "symbol": "WBTC",
                    "name": "Wrapped BTC",
                    "address": "0x68f180fcce6836688e9084f035309e29bf0a2095",
                    "decimals": 8,
                    "supportsBridging": false,
                    "withdrawalFee": 0,
                    "depositFee": 0,
                    "surgeEnabled": false
                },
                {
                    "id": "usdt",
                    "symbol": "USDT",
                    "name": "Tether USD",
                    "address": "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58",
                    "decimals": 6,
                    "supportsBridging": true,
                    "withdrawalFee": 0,
                    "depositFee": 0,
                    "surgeEnabled": false
                },
                {
                    "id": "dai",
                    "symbol": "DAI",
                    "name": "Dai Stablecoin",
                    "address": "0xda10009cbd5d07dd0cecc66161fc93d7c9000da1",
                    "decimals": 18,
                    "supportsBridging": false,
                    "withdrawalFee": 0,
                    "depositFee": 0,
                    "surgeEnabled": false
                },
                {
                    "id": "usdc",
                    "symbol": "USDC",
                    "name": "USD Coin",
                    "address": "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
                    "decimals": 6,
                    "supportsBridging": true,
                    "supportsPermit": true,
                    "withdrawalFee": 0,
                    "depositFee": 0,
                    "surgeEnabled": false
                }
            ]
        }
  ]
}
```

Since the `tokenSupport` field is `"All"`, routes involving this chain are supported for tokens where Solver or DEX liquidity is available.

### Example: Limited Token Support

```json theme={null}
{
  "chains": [
        {
            "id": 7777777,
            "name": "zora",
            "displayName": "Zora",
            "tokenSupport": "Limited",
            "currency": {
                "id": "eth",
                "symbol": "ETH",
                "name": "Ether",
                "address": "0x0000000000000000000000000000000000000000",
                "decimals": 18,
                "supportsBridging": true
            },
            "erc20Currencies": [
                {
                    "id": "usdc",
                    "symbol": "USDzC",
                    "name": "USD Coin (Bridged from Ethereum)",
                    "address": "0xcccccccc7021b32ebb4e8c08314bd62f7c653ec4",
                    "decimals": 6,
                    "supportsBridging": true,
                    "withdrawalFee": 0,
                    "depositFee": 0,
                    "surgeEnabled": false
                }
            ]
        }
  ]
}
```

Here, `tokenSupport` is `"Limited"`, meaning only specific tokens can be bridged. In this case, `usdc` is listed under `erc20Currencies` with `supportsBridging: true`, so routes involving `usdc` as an origin or destination token on Zora are supported.

## Gas Top-Up

For full documentation on enabling gas top-up and checking support requirements, see [Gas Top-Up](/features/gas-top-up).

## API Reference

For the most up-to-date information on supported tokens and routes, always refer to the [Chains API](https://api.relay.link/chains) endpoint, as token support can change over time.