# Token conversion authorizations

Source: https://docs.settlemint.com/docs/api-reference/tokens/token-conversion-authorizations
Read which target tokens a DALP token can convert into, and which source tokens can convert into it, through two paginated conversion authorization endpoints.



A convertible DALP token can be authorized to convert into one or more target tokens. DALP exposes that authorization as a pair of read endpoints. Together they answer two questions for any token: which target tokens it can convert into, and which source tokens can convert into it.

Use this reference to confirm a conversion route before initiating a conversion, or to reconcile the convertible side of an instrument with its target side. Both endpoints are read-only. They report indexed authorization state and never create, change, or revoke a route.

## Two directions of the same authorization [#two-directions-of-the-same-authorization]

A conversion authorization is a directed link between a source token and a target token. The two endpoints read the same authorization from opposite ends:

| Endpoint                                                      | Direction | Returns                                                 |
| ------------------------------------------------------------- | --------- | ------------------------------------------------------- |
| `GET /api/v2/tokens/{tokenAddress}/conversion/converts-to`    | Forward   | Target tokens this token is authorized to convert into. |
| `GET /api/v2/tokens/{tokenAddress}/conversion/converted-from` | Reverse   | Source tokens authorized to convert into this token.    |

Call `converts-to` with the source token in the path to list its targets. Call `converted-from` with the target token in the path to list its sources. Both responses use the standard DALP paginated list shape.

## List target tokens (converts-to) [#list-target-tokens-converts-to]

```bash
curl --globoff "$DAPI_URL/api/v2/tokens/0x1111111111111111111111111111111111111111/conversion/converts-to?page[limit]=50&sort=-authorizedAt" \
  -H "X-Api-Key: $DALP_API_TOKEN"
```

```json
{
  "data": [
    {
      "targetTokenAddress": "0x2222222222222222222222222222222222222222",
      "conversionFeatureAddress": "0x3333333333333333333333333333333333333333",
      "minterFeatureAddress": "0x4444444444444444444444444444444444444444",
      "isAuthorized": true,
      "authorizedAt": "2026-06-06T12:00:00.000Z",
      "revokedAt": null,
      "updatedAt": "2026-06-06T12:00:00.000Z"
    }
  ],
  "meta": {
    "total": 1,
    "facets": {}
  },
  "links": {
    "self": "/v2/tokens/0x1111111111111111111111111111111111111111/conversion/converts-to?sort=-authorizedAt&page%5Boffset%5D=0&page%5Blimit%5D=50"
  }
}
```

## List source tokens (converted-from) [#list-source-tokens-converted-from]

```bash
curl --globoff "$DAPI_URL/api/v2/tokens/0x2222222222222222222222222222222222222222/conversion/converted-from?page[limit]=50&sort=-authorizedAt" \
  -H "X-Api-Key: $DALP_API_TOKEN"
```

```json
{
  "data": [
    {
      "sourceTokenAddress": "0x1111111111111111111111111111111111111111",
      "conversionFeatureAddress": "0x3333333333333333333333333333333333333333",
      "minterFeatureAddress": "0x4444444444444444444444444444444444444444",
      "isAuthorized": true,
      "authorizedAt": "2026-06-06T12:00:00.000Z",
      "revokedAt": null,
      "updatedAt": "2026-06-06T12:00:00.000Z"
    }
  ],
  "meta": {
    "total": 1,
    "facets": {}
  },
  "links": {
    "self": "/v2/tokens/0x2222222222222222222222222222222222222222/conversion/converted-from?sort=-authorizedAt&page%5Boffset%5D=0&page%5Blimit%5D=50"
  }
}
```

## Fields [#fields]

The two endpoints return the same edge fields. They differ only in which token address is the counterparty: `converts-to` returns `targetTokenAddress`, and `converted-from` returns `sourceTokenAddress`.

| Field                                 | Meaning                                                                                                                  |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `targetTokenAddress` (converts-to)    | The token this token is authorized to convert into.                                                                      |
| `sourceTokenAddress` (converted-from) | The token authorized to convert into this token.                                                                         |
| `conversionFeatureAddress`            | Address of the conversion feature on the source side of the route. `null` until DALP has indexed it.                     |
| `minterFeatureAddress`                | Address of the minter feature on the target side of the route, used to issue the converted tokens. `null` until indexed. |
| `isAuthorized`                        | `true` while the conversion route is active, `false` once it has been revoked.                                           |
| `authorizedAt`                        | When the route was authorized.                                                                                           |
| `revokedAt`                           | When the route was revoked, or `null` while it remains authorized.                                                       |
| `updatedAt`                           | When the indexed edge last changed.                                                                                      |

## Query controls [#query-controls]

Both endpoints use the standard JSON:API query pattern for pagination, sorting, filtering, and facets.

| Control    | Supported fields               | Notes                                                                                                                          |
| ---------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ |
| Sort       | `authorizedAt`                 | The default sort is newest `authorizedAt` first. DALP uses the counterparty token address as a stable tie-breaker.             |
| Filter     | `isAuthorized`, `authorizedAt` | Filter on `isAuthorized` to list only active routes or only revoked routes.                                                    |
| Facets     | `isAuthorized`                 | Use the facet to count active and revoked routes without a second request.                                                     |
| Pagination | `page[limit]`, `page[offset]`  | The default page size is 50, with a maximum of 200. Page through results instead of assuming every route fits in one response. |

These endpoints do not support global text search.

## Behaviour [#behaviour]

* A token with no authorized or revoked conversion routes returns an empty `data` array with `total` set to `0`. The endpoint does not infer routes from another token or tenant.
* A revoked route is still returned, with `isAuthorized` set to `false` and `revokedAt` populated. Filter on `isAuthorized` when you want only the active routes.
* The endpoints read indexed authorization state. The read does not make a live contract call, authorize a new route, revoke a route, or execute a conversion.
* Results are scoped to the tokens your organization can see. A token outside that scope returns an empty paginated response rather than an error.

## SDK and CLI [#sdk-and-cli]

The same reads are available through the SDK and CLI.

```ts fixture=dalp-client
const targets = await client.token.convertsTo({
  params: { tokenAddress: "0x1111111111111111111111111111111111111111" },
  query: { filter: { isAuthorized: true } },
});

const sources = await client.token.convertedFrom({
  params: { tokenAddress: "0x2222222222222222222222222222222222222222" },
  query: { filter: { isAuthorized: true } },
});
```

```bash
dalp tokens converts-to 0x1111111111111111111111111111111111111111
dalp tokens converted-from 0x2222222222222222222222222222222222222222
```

## Related [#related]

* [Token conversion records](/docs/api-reference/tokens/token-conversion-records) to reconcile completed conversions across the source and target tokens.
* [Token conversion triggers](/docs/api-reference/tokens/token-conversion-triggers) to read the triggers that drive a conversion.
* [Conversion token feature](/docs/architects/components/token-features/conversion) for how the convertible instrument is configured.
* [Token lifecycle API](/docs/api-reference/tokens/token-lifecycle) for the wider token read surface.
* [API reference](/docs/api-reference/reference/openapi) for the generated OpenAPI contract and a typed client for these endpoints.
