# Payment fees explained: what a $100 sale leaves you

> A $100 sale leaves you with $94.80 after a $3.20 card processing fee and a $2.00 platform fee, with zero fees when withdrawing to your bank.

**On a standard $100 sale with thelastapi, you receive $94.80 in your balance after paying $3.20 in card processing and a $2.00 platform fee.** Card processing for most US cards takes 2.9% plus 30¢ ($3.20), while thelastapi platform fee takes 200 basis points, or 2% ($2.00). There is no withdrawal fee when you send the available balance to your bank account.

Understanding payment processing fees is essential when setting software pricing and forecasting cash flow. When you [take payments online without opening a merchant account](https://thelastapi.dev/blog/take-payments-without-merchant-account), thelastapi acts as the merchant of record from day one. Here is exactly what is deducted from each transaction, how the funds clear, and how fees behave on refunds, chargebacks, and international sales.

## How a $100 sale breaks down

Every card transaction incurs processing costs from the card networks and the processor. On top of that, thelastapi applies a platform fee to handle the merchant entity, hosted checkout, security, and sales tax compliance infrastructure.

When a customer buys a $100 product, the money splits into three line items:

| Fee component | Rate | Amount on $100 | What it covers |
| --- | --- | --- | --- |
| Card processing fee | 2.9% + 30¢ | $3.20 | Processing for most US cards (`fee_cents`) |
| Platform fee (`platform_bps`) | 2.0% (200 bps) | $2.00 | Merchant infrastructure and platform operations |
| **Net balance** | **94.8%** | **$94.80** | **The funds deposited into your project balance** |

You can inspect the exact rate object directly by calling `GET /v1/projects/:id/payments`:

```json
"fees": {
  "platform_bps": 200,
  "own_account_bps": 200,
  "card_fee_bps": 290,
  "card_fee_fixed_cents": 30,
  "dispute_fee_cents": 1500,
  "hold_days": 7,
  "example": {
    "amount_cents": 10000,
    "card_fee_cents": 320,
    "platform_fee_cents": 200,
    "net_cents": 9480
  }
}
```

The exact card processing fee shows on every completed payment object as `fee_cents`. When the transaction succeeds, `$94.80` (`net_cents: 9480`) lands in your project balance ledger immediately.

## How the money moves from checkout to your bank

Because thelastapi acts as the merchant, you do not need to submit personal tax documents or wait for an underwriting review before you start charging buyers. However, financial regulations require a brief clearing window before those funds can be sent to an outside bank account.

```text
 buyer ──card──▶ thelastapi (merchant, statement "VIBIZ, INC* <APP>")
                    │
                    ▼
       project balance   pending ── 7 days ──▶ available
                    │
                    │  owner: Get paid (identity + bank, once), then Withdraw
                    ▼
               the owner's bank
```

Money moves through three stages:

1. **Pending balance (`hold_days: 7`).** Live transactions remain pending for seven days to guard against early fraud or immediate cancellations. You can check `balance.next_available_at` in the dashboard or via the API to see when pending batches unlock. (In development mode, this hold is 0 days so you can test instantly.)
2. **Available balance.** After seven days, the net proceeds automatically convert from pending to available.
3. **Withdrawal.** Once funds are available, the account owner completes the "Get paid" step once in the console (verifying identity and linking a bank account). After verification, the owner can initiate a withdrawal in the console or via the CLI:

```bash
vibiz payments withdraw --amount 9480
```

There is **no withdrawal fee** charged by thelastapi. What is in your available balance is what reaches your bank. Withdrawals are currently supported for bank accounts in the US, Canada, the UK, the European Economic Area (EEA), and Switzerland.

## What refunds and chargebacks cost

Not every sale stays settled. When customer disputes or refund requests occur, processing fees behave differently. For a full operational breakdown, see our guide on [refunds and disputes: how they work and what they cost](https://thelastapi.dev/blog/refunds-disputes-explained).

### Refunds

If you issue a full refund on that $100 transaction, the customer receives their full $100 back. However, the card networks and the processor do not return the original $3.20 processing fee, and the $2.00 platform fee is not returned.

To cover the full $100 returned to the customer, your project balance must supply the remaining $5.20. A refund cannot exceed what remains of a payment, and if your total balance (available plus pending) cannot cover the refund, the API returns a `409` error with `reason: insufficient_balance`. A project's first sale can always be refunded in full.

### Chargebacks and disputes

If a customer disputes the charge with their card issuer instead of requesting a refund, the issuer pulls the funds back immediately pending investigation. 

A dispute removes:
- The disputed amount ($100).
- A **$15 dispute fee** (`dispute_fee_cents: 1500`).

Both amounts are deducted from your balance as soon as the dispute is opened. If you provide evidence and win the dispute, the disputed amount and the $15 fee are returned to your balance. If you lose, the deduction is permanent. If chargebacks push your ledger into a negative balance, future withdrawals are blocked until new sales clear the negative amount.

## Selling in non-USD currencies

thelastapi supports 35 different currencies, including `usd`, `eur`, `gbp`, `cad`, `aud`, `jpy`, and `chf`. 

When selling in other currencies, keep three fee and settlement rules in mind:

- **The balance stays in USD.** When an EU customer buys a subscription in Euros, the payment processor converts the foreign currency into USD at the wholesale exchange rate of the day minus the processor's currency-conversion fee (typically 1% to 2%).
- **Minimum transaction sizes apply.** Each currency enforces a minimum checkout size. For example, checkouts require at least 50 cents in USD, EUR, CAD, AUD, NZD, and CHF; 30 pence in GBP; and ¥50 in JPY.
- **Zero-decimal currencies use integer units.** While USD and EUR checkouts take prices in cents (for example, `10000` for $100.00), zero-decimal currencies like Japanese Yen (`jpy`), South Korean Won (`krw`), and Chilean Peso (`clp`) take whole units (`5000` means ¥5,000).

The payment record stores both figures: `amount_cents` and `currency` show what the buyer paid, while `settled_usd_cents` shows the exact USD amount deposited into your balance after foreign exchange conversion.

## Testing payments and fees in code

You can inspect fees, simulate test payments, and build checkout sessions locally without moving real money or incurring fees. 

In development mode, test checkouts use test card numbers (`4242 4242 4242 4242`, any future expiration date, any CVC) and have no 7-day hold.

Create a product and generate a checkout link using the CLI:

```bash
# Add a product in development
vibiz payments products add "Standard Plan" --amount 10000 --interval month --lookup-key standard-monthly --dev

# Generate a checkout URL for a buyer
vibiz payments checkout standard-monthly \
  --success-url http://localhost:3000/success \
  --cancel-url http://localhost:3000/pricing \
  --dev
```

In your application code, handle checkouts on the server using `@vibiz/app`. For detailed routing examples, visit the guide to [Payments in the app (@vibiz/app)](https://thelastapi.dev/docs/guides/app-payments):

```ts
import { vibiz } from '@vibiz/app';
import { redirect } from 'next/navigation';

export async function createCheckoutSession(userId: string) {
  const { url } = await vibiz.payments.checkout({
    lookup_key: 'standard-monthly',
    user: userId,
    success_url: 'https://app.example.com/billing/success',
    cancel_url: 'https://app.example.com/pricing',
  });

  redirect(url);
}
```

Whenever a checkout completes, thelastapi posts an event to your application endpoint. You can read how to [verify payment webhooks safely](https://thelastapi.dev/blog/verify-payment-webhooks) to ensure signature validation happens on the raw request body before fulfilling orders.

## Connecting your own account

If your company grows and you later register a business entity, you can connect your own processor account directly through the console or the CLI:

```bash
vibiz payments connect
```

When you connect your own processor account:
- New sales process on your own merchant account with your negotiated card processing rates.
- thelastapi retains an application fee of 200 basis points (`fees.own_account_bps: 200`), or none if set to 0.
- Existing funds earned through the thelastapi merchant balance remain in the project balance and can be withdrawn as usual.
- Subscriptions created under the default merchant account continue billing there without breaking customer service.

Read the [Payments](https://thelastapi.dev/docs/payments) documentation for a complete reference on ledger balances, statement suffixes, and API parameters.

To start testing payments, create your project using `vibiz init "My App"`, run `vibiz payments --dev` to check your test ledger, and inspect the fee calculations before going live.

## Frequently asked questions

### Why are payment processing fees not refunded when a customer returns a product?

Card networks and payment processors perform the work of moving money during the initial purchase and do not refund interchange and network charges when reversing the charge. Because of this, original card processing fees ($3.20 on a $100 sale) and the thelastapi platform fee ($2.00) are not returned.

### How long do I have to wait before I can withdraw my sales earnings?

Live payments are held as pending for 7 days (`fees.hold_days`) to protect against early fraud and immediate disputes. Once the 7-day clearing period passes, the funds convert to your available balance and can be withdrawn to your bank account at any time.

### What does the customer see on their credit card statement?

By default, the statement shows `VIBIZ, INC* <APP>` or your custom statement suffix. You can configure a custom suffix of 1 to 10 alphanumeric characters so buyers recognize your brand name next to the merchant identifier.

### Are there any monthly minimums or hidden recurring fees to keep payments active?

No. There are no monthly maintenance fees, gateway setup charges, or account maintenance costs. You pay standard fees only when a sale occurs: 2.9% + 30¢ for card processing plus 2% (200 basis points) for the platform.

---

Published 2026-11-15 · https://thelastapi.dev/blog/payment-fees-100-sale
