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

# Mint test tokens

> Sandbox only. Mints test USDC and USDT on Base Sepolia into one of a customer's custodial wallets, so you can fund wallet tests yourself.

Mints test stablecoins into a customer's wallet so you can exercise wallet-funded flows (quotes, transactions, transfers) without asking Endl for funds. Every call mints **up to 10 tokens per token**, on **Base Sepolia**. Returns `201` once the mint has gone through.

**Sandbox only.** The tokens are testnet assets with no value. In production the call is refused with `403 ERRWLT_1013` before anything else is checked.

**Custodial EVM wallets only.** The tokens are minted on Base Sepolia, so the wallet must be a custodial wallet on an EVM network (`BaseSepolia` or `EthereumSepolia`). A TronNile wallet is `400 ERRWLT_1003`; an external wallet is `400 ERRWLT_1011`.

**The body is optional.** With no body the call mints 10 USDC and 10 USDT. Send `token` or `tokens` to choose, and `amount` to mint less than 10.

**The new balance shows in [Get wallet balance](https://docs.endl.io/api-reference/wallets/get-wallet-balance.md).** The mint response does not carry a balance. In sandbox the new tokens are normally visible by the time the call returns.

**Not idempotent.** Every successful call mints again. Each call is capped at 10 per token, but repeated calls add up.

Requires the `wallets` permission.

> [!NOTE]
>
> A new sandbox EVM wallet is already seeded with 100 test USDC and 100 test USDT shortly after it is created. Use this endpoint to top it up, or to fund it again after your tests spend it.

## Request body

| Field | Type | Required | Description |
| - | - | - | - |
| `token` | string | No | `USDC` or `USDT` (case-insensitive). Send `token` **or** `tokens`, not both. |
| `tokens` | string\[] | No | Non-empty array of `USDC` / `USDT`. Duplicates are ignored. Default when neither is sent: `["USDC", "USDT"]`. |
| `amount` | number or numeric string | No | Tokens minted **per token**. Greater than `0` and at most `10`. Default `10`. |

Any other field is ignored.

## Response

| Field | Type | Description |
| - | - | - |
| `walletId` | string | The wallet that received the tokens, as your `wlt_…` reference. |
| `network` | string | The network the tokens were minted on. Always `BaseSepolia`. |
| `tokens` | string\[] | The tokens minted. |
| `amount` | string | Tokens minted per token. |
| `tx.id` | string | Id of the mint transaction. Quote it to support if a mint looks wrong. |
| `tx.status` | string | `completed` when the mint went through. In the rare case it is still processing, the wallet service's own state in lowercase, e.g. `pending`. |
| `message` | string | `Minting test funds for the wallet was done successfully`, or `Minting test funds for the wallet was submitted and is still processing` alongside a non-`completed` status. |

## Errors

| Status | Code | When |
| - | - | - |
| `400` | `ERRWLT_1014` | `token` / `tokens` is not `USDC` or `USDT`, `tokens` is empty or not an array, both `token` and `tokens` were sent, `amount` is not a positive number, `amount` is above `10`, or the body is not a JSON object. |
| `400` | `ERRWLT_1003` | The wallet is not on an EVM network (for example a TronNile wallet). |
| `400` | `ERRWLT_1011` | The wallet is an external wallet. **field:** `walletId` |
| `400` | `ERRREF_1000` | `{walletId}` is blank, malformed, or not a `wlt_…` reference. **field:** `walletId` |
| `400` | `ERRCORE_1001` | The version header is missing, malformed, or names a version the server does not support. **field:** `Api-Version` |
| `401` | `ERRCORE_1004` | The `Api-Key` header is missing, does not match an active credential, or its partner is inactive. |
| `403` | `ERRWLT_1013` | Called outside the sandbox environment. |
| `403` | `ERRCORE_1005` | The key is valid but lacks the `wallets` permission, or the calling IP is outside the allow-list configured on the key. |
| `404` | `ERRREF_1001` | `{userId}` or `{walletId}` is well-formed but resolves to nothing. |
| `404` | `ERRWLT_1000` | The wallet exists but belongs to another customer, or has been deleted. |
| `429` | `ERRCORE_1006` | The per-API-key limit was exhausted. Carries `X-RateLimit-Limit` and `X-RateLimit-Remaining`. |
| `500` | `ERRCORE_1000` | An unexpected server error, or the wallet service failed to mint. **Safe to retry** — the worst case is a second mint of test tokens. Quote the `X-Request-ID` when reporting it. |

```bash cURL — default (10 USDC + 10 USDT) theme={null}
curl --request POST \
  --url https://api-sandbox.endl.io/api/v0/wallets/cus_WgFF4jOrynBaJnRoUeq0/wlt_71reiTSLlmvQtN9XTqkn/mint-test \
  --header 'API-KEY: <api-key>' \
  --header 'Api-Version: 2026-09.1'
```

```bash cURL — 5 USDC theme={null}
curl --request POST \
  --url https://api-sandbox.endl.io/api/v0/wallets/cus_WgFF4jOrynBaJnRoUeq0/wlt_71reiTSLlmvQtN9XTqkn/mint-test \
  --header 'API-KEY: <api-key>' \
  --header 'Api-Version: 2026-09.1' \
  --header 'Content-Type: application/json' \
  --data '{ "token": "USDC", "amount": 5 }'
```

```json 201 theme={null}
{
  "walletId": "wlt_71reiTSLlmvQtN9XTqkn",
  "network": "BaseSepolia",
  "tokens": ["USDC", "USDT"],
  "amount": "10",
  "tx": {
    "id": "tx-01k6n-uav7n-e46ahjdmphu8f7vk",
    "status": "completed"
  },
  "message": "Minting test funds for the wallet was done successfully"
}
```

```json 400 — amount above the cap theme={null}
{
  "code": 400,
  "message": "amount must not exceed 10 per token in sandbox",
  "status": "ERROR",
  "data": null,
  "errors": [
    {
      "code": "ERRWLT_1014",
      "message": "amount must not exceed 10 per token in sandbox",
      "field": null
    }
  ]
}
```

```json 400 — TronNile wallet theme={null}
{
  "code": 400,
  "message": "Test tokens are minted on Base Sepolia, so only EVM wallets can receive them; this wallet is on TronNile",
  "status": "ERROR",
  "data": null,
  "errors": [
    {
      "code": "ERRWLT_1003",
      "message": "Test tokens are minted on Base Sepolia, so only EVM wallets can receive them; this wallet is on TronNile",
      "field": null
    }
  ]
}
```

```json 403 — production theme={null}
{
  "code": 403,
  "message": "Test token minting is not available",
  "status": "ERROR",
  "data": null,
  "errors": [
    {
      "code": "ERRWLT_1013",
      "message": "Test token minting is not available",
      "field": null
    }
  ]
}
```


## OpenAPI

````yaml api-reference/endl-partner-api.json POST /api/v0/wallets/{userId}/{walletId}/mint-test
openapi: 3.1.0
info:
  title: Endl Partner API
  version: '0'
  description: >-
    REST API for Endl partners: wallets, quotes, recipients, accounts and
    transactions.


    All endpoints are authenticated with an `API-KEY` header, are scoped to the
    partner that owns the credential, and return the standard response envelope.
servers:
  - url: https://api-sandbox.endl.io
    description: Sandbox
security:
  - apiKey: []
tags:
  - name: Wallets
    description: Create and manage user wallets.
  - name: Quotes
    description: Price a transfer before submitting it.
  - name: Recipients
    description: Manage the parties a user pays out to.
  - name: Accounts
    description: Open and inspect user accounts.
  - name: Transactions
    description: Fund, submit, and track transfers.
  - name: Reference
    description: 'Static catalogues: currencies, countries, rates, rails, codes.'
paths:
  /api/v0/wallets/{userId}/{walletId}/mint-test:
    post:
      tags:
        - Wallets
      summary: Mint test tokens
      description: >-
        **Sandbox only.** Mints test USDC and USDT on Base Sepolia into one of
        the customer's custodial EVM wallets, up to 10 tokens per token per
        call. Refused in production with `403 ERRWLT_1013`.


        The body is optional: with no body the call mints 10 USDC and 10 USDT.
        Not idempotent: every successful call mints again. The response carries
        no balance; read it with Get wallet balance.
      operationId: mintTestTokens
      parameters:
        - $ref: '#/components/parameters/ApiVersion'
        - name: userId
          in: path
          required: true
          schema:
            type: string
          description: >-
            Customer **reference id**, format `cus_<20 chars>` — never an
            internal UUID. Must belong to the authenticated partner.
          example: cus_WgFF4jOrynBaJnRoUeq0
        - name: walletId
          in: path
          required: true
          schema:
            type: string
          description: >-
            Wallet **reference id**, format `wlt_<20 chars>`. A custodial EVM
            wallet that belongs to the customer named in the path.
          example: wlt_71reiTSLlmvQtN9XTqkn
      requestBody:
        required: false
        content:
          application/json:
            schema:
              type: object
              properties:
                token:
                  type: string
                  enum:
                    - USDC
                    - USDT
                  description: >-
                    One token to mint (case-insensitive). Send `token` or
                    `tokens`, not both.
                tokens:
                  type: array
                  minItems: 1
                  items:
                    type: string
                    enum:
                      - USDC
                      - USDT
                  description: >-
                    Tokens to mint. Duplicates are ignored. Default `["USDC",
                    "USDT"]`.
                amount:
                  oneOf:
                    - type: number
                    - type: string
                  default: 10
                  description: Tokens minted per token. Greater than 0 and at most 10.
            example:
              token: USDC
              amount: 5
      responses:
        '201':
          description: The mint went through.
          content:
            application/json:
              schema:
                type: object
                properties:
                  walletId:
                    type: string
                    description: The wallet that received the tokens (`wlt_…`).
                  network:
                    type: string
                    description: Always `BaseSepolia`.
                  tokens:
                    type: array
                    items:
                      type: string
                  amount:
                    type: string
                    description: Tokens minted per token.
                  tx:
                    type: object
                    properties:
                      id:
                        type: string
                        description: Id of the mint transaction.
                      status:
                        type: string
                        description: >-
                          `completed`, or the wallet service's own state in
                          lowercase (e.g. `pending`) if still processing.
                  message:
                    type: string
              example:
                walletId: wlt_71reiTSLlmvQtN9XTqkn
                network: BaseSepolia
                tokens:
                  - USDC
                  - USDT
                amount: '10'
                tx:
                  id: tx-01k6n-uav7n-e46ahjdmphu8f7vk
                  status: completed
                message: Minting test funds for the wallet was done successfully
        '400':
          description: >-
            `ERRWLT_1014` — invalid `token`/`tokens`/`amount` or amount above
            10. `ERRWLT_1003` — not an EVM wallet. `ERRWLT_1011` — external
            wallet. `ERRREF_1000` — malformed path reference. `ERRCORE_1001` —
            bad `Api-Version`.
          content:
            application/json:
              example:
                code: 400
                message: amount must not exceed 10 per token in sandbox
                status: ERROR
                data: null
                errors:
                  - code: ERRWLT_1014
                    message: amount must not exceed 10 per token in sandbox
                    field: null
        '401':
          description: '`ERRCORE_1004` — the `Api-Key` is missing, unknown or inactive.'
          content:
            application/json:
              example:
                code: 401
                message: Partner API key required
                status: ERROR
                data: null
                errors:
                  - code: ERRCORE_1004
                    message: Partner API key required
                    field: null
        '403':
          description: >-
            `ERRWLT_1013` — called outside sandbox. `ERRCORE_1005` — the key
            lacks the `wallets` permission, or the IP is outside the key's
            allow-list.
          content:
            application/json:
              example:
                code: 403
                message: Test token minting is not available
                status: ERROR
                data: null
                errors:
                  - code: ERRWLT_1013
                    message: Test token minting is not available
                    field: null
        '404':
          description: >-
            `ERRREF_1001` — the customer or wallet reference resolves to
            nothing. `ERRWLT_1000` — the wallet belongs to another customer or
            was deleted.
          content:
            application/json:
              example:
                code: 404
                message: Wallet 'wlt_00000000000000000000' not found
                status: ERROR
                data: null
                errors:
                  - code: ERRREF_1001
                    message: Wallet 'wlt_00000000000000000000' not found
                    field: walletId
        '429':
          description: >-
            `ERRCORE_1006` — per-API-key rate limit exceeded. Carries
            `X-RateLimit-Limit` and `X-RateLimit-Remaining`.
        '500':
          description: >-
            `ERRCORE_1000` — unexpected failure, or the wallet service failed to
            mint. **Safe to retry.**
components:
  parameters:
    ApiVersion:
      name: Api-Version
      in: header
      required: true
      description: >-
        The API version this request targets. Required on every `/api/v0/*`
        call. Format `YYYY-MM.<release>`; `2026-09.1` is the latest. The version
        that served the request is echoed back on the response. Missing,
        malformed or unsupported values are rejected with `400`.
      schema:
        type: string
        pattern: ^\d{4}-\d{2}\.\d+$
        default: 2026-09.1
      example: 2026-09.1
  securitySchemes:
    apiKey:
      type: apiKey
      in: header
      name: API-KEY
      description: Your partner API key.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.