# Fees and settlement

Every deposit that becomes final is **settled**: payitgo takes its fees and moves
the rest where your account says. You choose where, and who pays the fees.

A payment paid in parts is settled once, not once per part: while it is still
short (`pending` or `partially_paid`), and while another deposit of the same
coin is confirming, its final deposits wait. When it confirms, falls short at
its deadline (`underpaid`), expires or fails, the deposits of each coin are
settled together: one transfer out of the address, one network fee and one
service fee, on their total (`deposit_txs` lists them). A deposit that arrives
after that (a late one) is moved by a transfer of its own, and pays its own
fees.

## Fees

The fees come out of each deposit, in the asset that arrived:

| Fee | What it is | How much |
|---|---|---|
| Service fee | payitgo's fee | A percentage of the deposit agreed with your account (1% by default), and at least $0.20 |
| Network fee | Moving the deposit out of its address on the blockchain | Priced from the network's conditions right now |
| Conversion fee | Only for a deposit converted into another coin: into one of your payout coins on its way to your wallet ([coins you have no payout address for](#coins-you-have-no-payout-address-for)), or bought by payitgo for your balance ([custody in USDT](#custody-is-held-in-usdt-on-tron)) | 0.5% of what is swapped or converted (the exchange's own fee is in its rate); 1.5% of what payitgo buys |

The network fee follows the network: gas prices on Ethereum and BNB Smart
Chain, energy and bandwidth prices on Tron, fee rates on Bitcoin, Litecoin and
Dogecoin, the open-ledger fee on XRP. It is cents on most networks and a
dollar or two for USDT on Tron, where every token transfer needs energy:
payitgo rents it for well under what burning it would cost, and prices it so
(at the burn price only while it cannot rent). It is higher with direct
settlement, which makes two transfers instead of one. On Tron, sending
USDT to a payout address that holds no USDT burns about twice the energy (its
balance is created): a direct settlement to such an address pays that too,
and says so in its `note`. Keep a little USDT on your Tron payout address to
avoid it. A coin swapped into your payout coin on its own network is quoted
with the swap and the payout coin's two transfers, as it is charged; one
converted across networks, with the transfers to the exchange and what the
exchange keeps.

The network fee also covers **converting** a coin, when it is converted: what
the exchange keeps, and payitgo's 0.5% conversion fee (for a custody deposit
payitgo buys, its 1.5% conversion fee). Part of that is a share of the payment
rather than a fixed amount.

`GET /v1/tokens` shows each token's network fee for your settings right now.
Here, with direct settlement and payout addresses for USDT on Tron and on BNB
Smart Chain, a BTC payment is converted into USDT on Tron:

```json
{ "tokens": [
  { "token": "USDT_TRC20", "chain": "tron",    "min_usd": "10.56", "network_fee_usd": "5.28", "fee_note": "…" },
  { "token": "USDT_BEP20", "chain": "bsc",     "min_usd": "1",     "network_fee_usd": "0.01", "fee_note": "…" },
  { "token": "BTC",        "chain": "bitcoin", "min_usd": "13.2",  "network_fee_usd": "6.6",  "network_fee_bps": 180, "fee_note": "…" }
] }
```

`network_fee_usd` is the fixed part, whatever the amount; `network_fee_bps`
is the share of the payment added on top for a coin that is converted (180:
1.8%), left out when nothing is.

Each payment records the network fee quoted when its coin was chosen
(`network_fee` in the coin, `network_fee_usd` in dollars), what converting it
costs included. The deposit that pays the payment is charged that quote (one
swapped or converted across networks is priced as it is converted); any
other deposit to it (a second part payment, a late or wrong-asset deposit) is
priced when it settles. A settlement breaks it down: its `network_fee` is the
transfers, its `conversion_fee` payitgo's conversion fee, and the exchange's
share is already out of what the conversion bought (`amount_out`).

### Minimums

When you pay the fees yourself (`fees_paid_by_customer` off), a payment must
be worth at least twice the token's network fee, so the fees never eat it
(and never less than the token's own minimum).

A coin converted across networks on its way to your wallet
([which coins](#coins-you-have-no-payout-address-for)) must also leave the
exchange its minimum, with a tenth to spare: about 13 USDT from BNB Smart
Chain to Tron. With the fees passed on, that is reached from a price of
about $7.70 (the customer pays the exchange's cut on top). A smaller payment
is still offered in that coin: the customer is asked for enough to reach the
minimum, and you receive the extra (`extra_usd`). A $5 order, say, asks the
customer for about $13.50, and you receive about $7.70. To offer such a coin
only from the price that reaches the minimum, turn on `hide_below_minimum`
in your payment settings; when you pay the fees yourself, that is always
so.

The minimums move with the fees and the exchange: `min_usd` in
`GET /v1/tokens` is the current one, and creating a payment below it is
refused with `400`. A coin the amount is too small for is left out of the
customer's choices, and choosing it anyway is refused.

### Passing the fees on to the customer

With **`fees_paid_by_customer`** on, the default for a new account, your
customer pays the fees on top of your price, so you receive the full price.
Turn it off (`PATCH /merchant/settings`) and the customer pays your price
alone, and the fees come out of what you receive.

With it on:

```
amount_due_usd = (usd_amount + network_fee_usd) / (1 − service fee − network_fee_bps ÷ 10 000)
```

with the token's `network_fee_usd` and `network_fee_bps` from `GET /v1/tokens`
(and at least `usd_amount + network_fee_usd + $0.20`, the minimum service
fee). A $100 order in `USDT_TRC20` (network fee $1.39, service fee 1%) asks
the customer for $102.42, and $100.00 reaches you. For a coin that is
converted, the customer pays for converting it too, and your price still
reaches you. The payment's `usd_amount` stays your price; `amount_due_usd` and `crypto_amount` are what the customer pays,
and a payment is paid once `amount_due_usd` has arrived. When the customer
chooses the coin, each of the payment's `token_options` shows its own
`amount_due_usd`, so they can pick the cheapest network. With fees passed on,
the minimums are just each token's own.

## Where the money goes

| `settlement` | What happens | Fees |
|---|---|---|
| `direct` (default) | payitgo sends what remains to your own payout address for the token, minutes after the deposit is final; a coin you have no payout address for is first converted into one you have ([see below](#coins-you-have-no-payout-address-for)). Nothing stays with payitgo | Network fee of two transfers (yours, and payitgo's fee); for a converted coin, what converting it costs and the 0.5% conversion fee |
| `custodial` | payitgo keeps the money, in USDT on Tron: what remains after the fees is added to your balance (bought by payitgo for USDT if it arrived in another coin), and you request payouts when you like | Network fee of one transfer, and for any coin but USDT on Tron the 1.5% conversion fee |
| `scheduled` | Like `custodial`, and payitgo pays your whole balance out to your payout address for USDT on Tron as soon as it is credited, every day, or every week on Mondays (`payout_schedule`: `instant`, `daily`, `weekly`), in one payout | Network fee of one transfer per payment, and one payout's network fee per payout; for any coin but USDT on Tron the 1.5% conversion fee |

Direct settlement is the default, and the cheapest for you when you take
few payments: a coin you have a payout address for is not converted, and each
payment reaches you within minutes. A payment in a coin you have no payout
address ready for is converted into one of your payout coins on its way to
you ([see below](#coins-you-have-no-payout-address-for)), and is quoted that
way.

**Add a payout address for every coin you accept.** It costs nothing, and it
makes each coin's payments the cheapest they can be: they are sent to you as
they arrived, on their own network, with no swap, and your customers pay only
that network's transfers. A coin without one is converted first, and its
quote carries the conversion: a TRX payment swapped into USDT costs your
customer several dollars more than one sent to your TRX address, and TRX
sent as it is costs nothing to move. You can have an address for each coin
on each network: USDT on Tron and USDT on BNB Smart Chain are two coins, each
with its own address.

Scheduled settlement is the cheapest when you take several payments a day in
USDT on Tron: each pays the network fee of one transfer instead of two (about
$1.39 against $2.40), and one payout a day (or week) pays the rest. Your
balance is paid out at a fixed hour to your payout address for USDT on Tron,
once direct settlement uses it (its `active_at`: at once for your first, 24
hours after a change; [payout addresses](/docs/account#payout-addresses));
a balance under the minimum payout ($10) waits for the next time. With
`payout_schedule: "instant"` a payout is requested the moment a payment is
credited to your balance (one per payment, so the per-payment saving is
spent on the payout's fee: it suits payments in other coins, which reach you
as USDT on Tron without an exchange's fees, and large payments).
The payout then follows the usual steps (`requested`, `approved`, `sent`),
with `requested_by: "scheduler"`.

Switch with `PATCH /merchant/settings {"settlement": "custodial"}` or
`{"settlement": "scheduled", "payout_schedule": "daily"}` (owner only). The
setting is captured when a payment is created: a payment keeps the mode it
was created under.

### Custody is held in USDT on Tron

Your balance with payitgo is always in **USDT on Tron** (`USDT_TRC20`), so what
payitgo owes you never moves with a coin's price. A custody deposit in any
other coin (BTC, ETH, BNB, USDT on Ethereum or BNB Smart Chain…) is **bought
by payitgo** as it settles: you are credited at once its value in USDT on Tron
at the market price, less the fees and a 1.5% conversion fee. Its settlement's
`conversion` shows `"via": "platform"`, the price and what you received:

```json
{
  "conversion": { "via": "platform", "from": "BTC", "amount_in": "0.00117", "to": "USDT_TRC20",
                  "amount_out": "96.52", "status": "done", "note": "bought by payitgo at the market price, 82499.98 USD per BTC" }
}
```

There is no exchange to wait for and no exchange fee on top: payitgo converts
the coins it bought later, in large batches, at its own cost.

To be paid in the coin your customers pay with, use direct settlement. Test
payments are not converted: test custody stays in the coin that arrived.

### Direct settlement

Direct settlement pays each token to that token's **default payout address**
in the payment's mode. The first address you add for a token is its default;
make another one the default with `PATCH /merchant/payout-addresses/{id}
{"default": true}`. Test payments settle to test addresses (add them with
`?mode=test`), live payments to live ones.

Your first **live** address of a coin is used for direct settlement at once:
there was nowhere else for those payments to go. Any address that could
redirect payments waits 24 hours (`active_at`): another address of a coin, a
changed address or tag, or one added after the coin's last address was
deleted. So whoever might take over your account cannot redirect your
incoming payments at once, and your team is told of every change (a
`security` notification). Test addresses are used immediately.

When the address for a deposit's coin is still in its 24 hours, the deposit
waits on its deposit address until the address is used, and is then sent
there as it is, never converted: its settlement is `pending`, with
`awaits_address.until` (when the address is used) and a `note`, and its fees
are worked out when it is sent. Changing the address again restarts the
wait, for up to 48 hours from the deposit; after that, or when the address
is deleted, it is settled as if there were none.

When a deposit has no address of its own coin at all, it is converted into
a coin whose payout address is in use (past its `active_at`) and sent there
([coins you have no payout address for](#coins-you-have-no-payout-address-for)).
When it cannot be, it is kept in your balance instead, in USDT on Tron like
any custody deposit, and its settlement says why in `note`. Nothing is ever
lost: payitgo pays that balance out to your USDT address on BNB Smart Chain
(or Ethereum) by itself once you have one in use
([payouts](#payouts)); without one, request a payout of it as usual.

On XRP, payitgo's fee stays on its own address, so a direct XRP settlement is a
single transfer. For an exchange account, give the payout address the
destination tag the exchange asks for (`tag`).

### Following settlements

Every final deposit gets a **settlement**: what arrived, the fees taken, what
you received and where it went. Read them with a dashboard access token (any
role):

| Method | Path | What it does |
|---|---|---|
| `GET` | `/merchant/settlements` | List settlements, newest first |
| `GET` | `/merchant/settlements/{id}` | One settlement |

| Query parameter | Default | Description |
|---|---|---|
| `mode` | live | `test` for test settlements |
| `status` | all | `pending`, `completed`, `held` or `failed` |
| `payment_id` | all | Only this payment's settlements (one per deposit, or one for its deposits of a coin paid in parts) |
| `settlement` | all | `direct` or `custodial` |
| `limit`, `offset` | 50, 0 | Paging; `limit` 1 to 200 |

```bash
curl -s 'https://api.payitgo.co/merchant/settlements?payment_id=8f3a2c1e9b7d4a6f05e1c2d3' \
  -H "Authorization: Bearer $ACCESS_TOKEN"
```

`200 OK`:

```json
{
  "settlements": [
    {
      "id": "0441481512422d5c1e2ce3ab",
      "payment_id": "8f3a2c1e9b7d4a6f05e1c2d3",
      "deposit_tx": "c192401935e4ac25bb5f7cdba7443ada0e097cfdb537710236bf7d98c60851bd",
      "livemode": true,
      "mode": "direct",
      "token": "USDT_TRC20",
      "chain": "tron",
      "amount": "49.9",
      "service_fee": "0.499",
      "network_fee": "6.019231",
      "conversion_fee": "0",
      "net": "43.381769",
      "usd_value": "49.9",
      "usd_rate": "1",
      "service_fee_usd": "0.5",
      "network_fee_usd": "6.02",
      "conversion_fee_usd": "0",
      "net_usd": "43.38",
      "destination": "TWd4Kp9mR2xH7sN3vB6cJ8fL5qY1tZgEaU",
      "tx_id": "16d7a564712e9079cddc178e2a80b8d2b6284574cc5bfeb8272580de9f6cae4e",
      "status": "completed",
      "created_at": "2026-10-10T09:04:03.81Z",
      "completed_at": "2026-10-10T09:05:12.4Z"
    }
  ],
  "total": 1,
  "limit": 50,
  "offset": 0
}
```

`GET /merchant/settlements/{id}` answers `200 {"settlement": {…}}` with the
same object, or `404 {"error": "settlement not found"}`.

#### The settlement object

| Field | Type | Description |
|---|---|---|
| `id` | string | The settlement's id |
| `payment_id` | string | The payment the deposit was made to |
| `store_id` | string, optional | The payment's store |
| `deposit_tx` | string | The deposit's transaction id (the payment's `deposits[].tx_id`); for several settled together, the first |
| `deposit_txs` | array of strings, optional | Every deposit it settles, when there are several (a payment paid in parts): their total is `amount` |
| `livemode` | boolean | `false` for a test settlement |
| `mode` | string | Where the money actually went: `direct` (your wallet) or `custodial` (your balance). A direct payment in a coin you have no payout address for, that cannot be converted into a coin whose address is in use, is kept in custody, and says so in `note` (one whose address is still in its 24 hours waits for it instead: `awaits_address`) |
| `token`, `chain` | string | The coin settled: what arrived, or what a swap on its own network bought. A deposit converted across networks is settled in the coin that arrived, and `conversion` says what it became |
| `conversion` | object, optional | When the deposit was converted, what arrived and what it became (below) |
| `amount` | decimal string | What is settled, in `token` |
| `service_fee` | decimal string | payitgo's service fee, in `token` |
| `network_fee` | decimal string | The network fee of moving it, in `token` |
| `conversion_fee` | decimal string | The conversion fee, in `token`; `"0"` when nothing was converted |
| `net` | decimal string | What is yours: `amount` less the three fees. Sent to `destination`, or credited to your balance. Converted across networks, it is what went to the exchange, and `conversion.amount_out` what reached you |
| `usd_value` | decimal string | `amount` in dollars, to the cent: at the payment's locked rate (`rate_locked`) for the payment's own coin, at the market price for another coin, or what the conversion bought, at the price then |
| `usd_rate` | decimal string | The dollar price of one `token` used: `usd_value` ÷ `amount`, to 8 decimals. `"1"` for USDT and USDC; `"0"` only for a settlement of nothing |
| `service_fee_usd`, `network_fee_usd`, `conversion_fee_usd` | decimal string | Each fee in dollars at `usd_rate`, to the cent |
| `net_usd` | decimal string | What is yours, in dollars: `usd_value` less the three fees in dollars, so the dollar figures add up exactly |
| `destination` | string, optional | Direct settlement: your payout address it was sent to |
| `destination_tag` | integer, optional | XRP: the tag it was sent with |
| `tx_id` | string, optional | Direct settlement: the transaction that paid you, once sent. For a deposit converted across networks, the exchange's payout to your wallet |
| `status` | string | See below |
| `note` | string, optional | Why it was held, kept in custody or converted the way it was, or what it waits for |
| `awaits_address` | object, optional | `{"until": "…"}`: waiting for your new or changed payout address for its coin, used from `until`; then it is sent there as it is. Its fees are `0` until then |
| `created_at` | string | When the deposit became final |
| `completed_at` | string, optional | When it completed |

| `status` | Meaning |
|---|---|
| `pending` | The transfers are being made (a token transfer may first need gas sent to the deposit address) |
| `completed` | Done. In direct settlement, `tx_id` is the transfer to your wallet |
| `held` | Nothing to move, and `note` says why: the deposit was smaller than its fees, or it is already where it needs to be |
| `failed` | It could not be sent after repeated tries. payitgo's team retries it, or returns it to your balance |

The `conversion` object:

| Field | Type | Description |
|---|---|---|
| `via` | string | `swap` (swapped on the deposit's own network), `exchange` (converted across networks) or `platform` (bought by payitgo at the market price) |
| `from`, `amount_in` | string | The asset that arrived, and how much |
| `to`, `amount_out` | string | What it became, and how much |
| `status` | string | `pending` (not swapped yet), `done`, or `skipped` (settled as it arrived; `note` says why) |
| `note` | string, optional | Details, such as the price payitgo bought at |

Direct settlements raise two webhooks, with this object as `data`:
`settlement.completed` once your share is on chain, and `settlement.failed` if
it could not be sent ([Webhooks](/docs/webhooks#events)). A payment created
with its own `webhook_url` gets its settlement events there too. Custody
settlements raise none: the money is in your balance once the payment is
`confirmed`.

### On your statement

Each deposit appears on your [ledger](/docs/account#ledger) (`GET /merchant/ledger`) as a
`payment_credit`, then a `fee`, a `network_fee` and, when converted, a
`conversion_fee` taken from it, and in direct settlement a `settlement` for
the part sent to your wallet, which leaves your balance unchanged. A direct
settlement that payitgo returns to your balance appears as a
`settlement_return`. A custody deposit payitgo buys is a `conversion_out` of
the coin that arrived and a `conversion_in` of the USDT on Tron you received
for it, at once.

## Coins you have no payout address for

The cheapest is not to need this: add a payout address for each coin you
accept ([why](#where-the-money-goes)). With direct settlement, a payment in a
coin you have no payout address for (say a customer pays in BTC and you only have a USDT on Tron address) is
**converted** into one of your payout coins and sent to your payout address
for it. A coin whose address is still in its 24 hours is not converted: its
payments wait for the address. There is nothing to turn on. A deposit in another asset than the
payment asked for
([wrong asset](/docs/payments#when-the-customer-pays-with-the-wrong-asset)) is
settled the same way: to your payout address for the coin that arrived, or
converted.

### Which payout coin

You choose it with **`convert_into`** in your payment settings:

- **`cheapest`** (the default): payitgo compares your payout coins for each
  payment and converts into the one that costs the least at that payment's
  amount: the swap or the exchange's take, the transfers, and the 0.5%
  conversion fee.
- **`order`**: the first of
  1. a coin on its own network that it is swapped into there, a stablecoin
     first (BNB or USDC into your USDT on BNB Smart Chain, say);
  2. otherwise USDT on Tron;
  3. otherwise the coin of your oldest payout address it can be converted
     into.
- **A coin**, any coin you have a payout address for (`BTC`, `USDT_BEP20`,
  `ETH`…): your preferred payout coin. Every coin you have no address for is
  converted into it and sent to your default address for it, whenever the
  payment can be converted into it at its amount (the exchange takes about
  $5 at least to pay out BTC, a few cents for USDT on BNB Smart Chain);
  otherwise the fixed order above decides. It is used even where another
  of your coins would cost less (TRX into your USDT on Tron, say), so
  choose `cheapest` to always save.

The difference can be large.
Receiving a conversion as USDT on Tron costs a few dollars (the exchange
pays the Tron network to send it), as USDT on BNB Smart Chain a few cents.
Converting a payment, as quoted on 2026-10-15:

| Paid in | Into USDT on Tron, $20 / $100 | Into USDT on BNB Smart Chain, $20 / $100 |
|---|---|---|
| BTC | $5.37 / $6.65 | $0.53 / $1.73 |
| XRP | $4.85 / $6.21 | $0.33 / $1.60 |
| ETH | $5.08 / $6.46 | $0.35 / $1.68 |
| TRX | $14.82 / $15.46 (swapped on Tron) | $0.33 / $1.66 |

A payment is quoted for the coin chosen when your customer picks theirs, and
converted into that coin when it settles, unless you have since added an
address for the coin it was paid in (it is then sent as it is) or removed
the one it was quoted for (one is chosen again). A coin the exchange would
not take that little of is passed over; when none would, the payment is kept
in your balance (see below).

On its own network, a coin is swapped on that network's exchange:

| Network | Swapped |
|---|---|
| Ethereum | ETH, USDC and USDT into one another |
| BNB Smart Chain | BNB, USDC and USDT into one another |
| Tron | TRX into USDT |

The swap is protected: the exchange's price must be within 3% of the market
price, and the swap is refused on chain if its result falls more than 0.5%
(between stablecoins, 1% otherwise) below the quote. The exchange's fee
(0.25–0.3%) is in its price, and the swap's network fees are added to the
deposit's network fee.

Across networks (BTC, XRP or ETH into USDT on Tron, say), an exchange converts
it: payitgo takes its fees in the coin that arrived and sends the rest to the
exchange, which pays your coin out to your payout address for it. The
exchange's own rate and network fees apply; its fixed part (a few dollars)
makes converting dear on small payments.

What converting costs is quoted with the payment, in its network fee
([fees](#fees)), and paid by the customer when you pass the fees on.
`GET /merchant/tokens` shows, for each coin, the share converting adds
(`network_fee_bps`) and the coin its payments are converted into
(`paid_out_in`).

The settlement's `conversion` says what happened:

```json
{
  "conversion": { "via": "swap", "from": "BNB", "amount_in": "0.3", "to": "USDT_BEP20", "amount_out": "221.98", "status": "done" }
}
```

```json
{
  "conversion": { "via": "exchange", "from": "BTC", "amount_in": "0.0021", "to": "USDT_TRC20", "amount_out": "196.42", "status": "done" }
}
```

Converted across networks, the settlement's `tx_id` is the exchange's payout
to your wallet. On your statement a swapped deposit is a `payment_credit` in
the coin it was swapped into, noting what arrived; one converted across
networks is a `payment_credit` in the coin that arrived, and its `settlement`
entry reads "converted into USDT_TRC20 and sent to your wallet".

A deposit is kept in your balance instead, bought by payitgo for USDT on Tron
like any [custody deposit](#custody-is-held-in-usdt-on-tron), and its
settlement's `note` says why, when:

- it converts into none of your payout coins;
- it is too small for the exchange's minimum (a few dollars, with a margin for
  the fees): `"too small to convert into USDT_TRC20: kept in your balance instead"`;
- a swap is not worth it (its network fees would be more than a tenth of its
  value: small deposits, and on Tron, where a swap burns about 20 TRX,
  deposits under about $65), the exchange's price is off the market, or the
  exchange refuses the swap twice;
- the exchange refunds it. Its conversion fee is then 1.5% in all (the 0.5%
  already charged, and the rest as its own `conversion_fee` entry).

Nothing is lost: it is paid out to you automatically once you have a USDT
address on BNB Smart Chain or Ethereum in use ([payouts](#payouts)), or
request a payout when you like. Add a payout address for a coin to receive
its next payments as they are. Conversion runs in live mode
only: in test mode a coin you have no test payout address for is credited to
your test balance as it arrived.

`GET /merchant/tokens` shows where each coin's payments go (`settles_to`:
`wallet`, with `paid_out_in` when they are converted on the way, or
`balance`; scheduled settlement is `balance`, paid out on the schedule). To
accept only coins you can be paid out in, enable only those in your
[accepted tokens](/docs/account#accepted-tokens).

## Payouts

A payout is charged the network fee of sending it, quoted when it is
requested: the payout's `network_fee`, with `send_amount` (the amount less the
fee) being what reaches your address. Each has its dollar value at the coin's
price when the payout was requested (`amount_usd`, `network_fee_usd`,
`send_amount_usd`, and that price as `usd_rate`). The smallest payout is $10.

USDT is worth $1 on every network, so a USDT balance is paid out to any of
your USDT payout addresses: your custody balance, held in USDT on Tron, to
your USDT address on BNB Smart Chain or Ethereum as well (the payout's
`from_token` and `from_chain` say which balance it draws on). The network
sets the fee: sending USDT costs about a cent on BNB Smart Chain and a few
dollars on Tron, and on Ethereum it moves the most with how busy the network
is. A payout in USDT on BNB Smart Chain or Ethereum is sent by payitgo
itself, usually within minutes of its approval.

With direct settlement, what stays in your balance (see above) is paid out
**automatically**: payitgo pays a USDT balance, all of it, to your USDT
address on BNB Smart Chain that direct settlement uses (past its
`active_at`), else to the one on Ethereum, and sends it itself, for a network
fee of about a cent on BNB Smart Chain. The payout has
`requested_by: "auto"`. A balance under $10 waits, and without such an
address you request payouts as usual. Custody is paid out on request, and
scheduled settlement on its schedule.

How to request one, and the payout object: [Balances and payouts](/docs/account#balances-and-payouts).

## In test mode

Test payments are [simulated](/docs/testing) and move no coins, but they are
settled like live ones, on paper:

- Each simulated deposit is settled when it is final (a payment paid in parts
  once, when it closes), with the same fees as
  live, and gets its settlement (`"livemode": false`).
- Coins are never converted: a test deposit settles in the coin that arrived,
  in direct settlement and in custody alike.
- With direct settlement and a test payout address, the settlement completes
  at once and sends `settlement.completed`. Nothing is sent to the address, so
  it has no `tx_id`.
- In custody, or with no test payout address for the coin, the net amount is
  credited to your **test** balance. Test balances are never paid out.