# Take payments online without opening a merchant account

> Take card payments online immediately using thelastapi as the merchant, with no merchant account setup, processor keys, or upfront identity checks.

**You can take payments online without opening a merchant account by using thelastapi as the merchant of record.** thelastapi provides card checkout for one-time and recurring charges the moment your project is created, with no processor keys to configure and no identity verification required before your first sale. Funds collect in your project balance, and when you are ready to withdraw, you complete a one-time identity verification and connect your bank account.

This architecture removes the operational friction of setting up individual merchant processor accounts before validating a product.

## Why opening a merchant account slows down a launch

Setting up traditional merchant accounts introduces significant delays when starting a software project:

- **Upfront underwriting and identity checks:** Most processors require corporate documentation, identity verification, business bank accounts, and manual underwriting reviews before you can run a single live charge.
- **Key management sprawl:** Managing separate test keys, live publishable keys, secret keys, and webhook signing secrets across development, staging, and production environments creates operational overhead.
- **Deferred time to market:** Launching an MVP or validating pricing with early users often stalls while waiting for merchant verification approvals.

By contrast, thelastapi acts as the merchant on card payments. Your customers see `VIBIZ, INC* <APP>` on their bank statements (or a custom 1–10 character statement suffix you specify), and you can accept live card payments right away.

## How payments work in thelastapi

When a customer pays through your application, the transaction moves directly through thelastapi into your project's balance:

```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
```

Live payments enter your project balance as `pending`. After a 7-day hold (`fees.hold_days`), the funds become `available` for withdrawal. In the development environment, there is no hold, which lets you [test payments in development without real money](https://thelastapi.dev/blog/test-payments-development-mode) before launching.

The balance is always maintained in USD. If you [sell in multiple currencies](https://thelastapi.dev/blog/sell-in-multiple-currencies), the processor settles the transaction into your balance at that day's exchange rate minus the currency conversion fee (about 1–2%).

## Setting up products and taking your first payment

You can define your product catalog and generate checkouts via the CLI or HTTP API. Product catalogs are strictly separated by environment, allowing you to build and test safely in development before re-creating catalog items in production.

To create a monthly recurring product in development using the CLI:

```bash
vibiz payments products add Pro --amount 1500 --interval month --lookup-key pro-monthly --dev
```

You can immediately create a hosted checkout session for this item:

```bash
vibiz payments checkout pro-monthly \
  --success-url http://localhost:3000/thanks \
  --cancel-url http://localhost:3000/pricing \
  --dev
```

To test the payment pipeline in development without using a card:

```bash
vibiz payments simulate payment --dev
vibiz payments list --dev
```

For production, run the same commands without the `--dev` flag:

```bash
vibiz payments products add Pro --amount 1500 --interval month --lookup-key pro-monthly
```

You can also create products and checkouts using curl with an account key (`vz_sk_…`):

```bash
curl https://thelastapi.dev/v1/projects/prj_123/payments/products?env=production \
  -H "Authorization: Bearer $VIBIZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pro",
    "price": {
      "unit_amount_cents": 1500,
      "type": "recurring",
      "interval": "month",
      "lookup_key": "pro-monthly"
    }
  }'
```

For complete implementation steps on billing cycles and tiers, read our guide to [add a subscription checkout to a SaaS](https://thelastapi.dev/blog/subscription-checkout-saas).

## Creating checkouts in your application with @vibiz/app

In your web application, `@vibiz/app` uses a single server-side key, `VIBIZ_APP_KEY`, to communicate with the payment API. Never expose this key in client-side code or public variables.

Install the package:

```bash
npm install @vibiz/app
```

Whenever a user clicks an upgrade button, generate a single-use checkout session. Checkout pages expire after 1 hour and are tied to a single buyer.

Here is a Next.js server action implementation:

```ts
'use server';

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

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

  redirect(url);
}
```

To verify if an authenticated user currently has access to a plan, query their status directly with `hasActive`:

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

export async function checkAccess(userId: string) {
  const isSubscribed = await vibiz.payments.hasActive(userId, 'pro-monthly');
  const details = await vibiz.payments.subscription(userId);
  return { isSubscribed, details };
}
```

For a full reference on managing subscriptions, customer portal sessions, and products in application code, consult the [Payments in the app guide](https://thelastapi.dev/docs/guides/app-payments).

## Webhooks and handling successful charges

To grant user access and fulfill orders, handle webhook notifications sent by thelastapi. 

On thelastapi hosting or when your custom domain is connected, production webhooks are routed to `/api/vibiz/webhook` automatically. In development, point the webhook to your local server:

```bash
vibiz payments webhook http://localhost:3000/api/vibiz/webhook --dev
```

In your endpoint, pass the raw incoming request to `vibiz.webhooks.receive`. It verifies the HMAC-SHA256 signature using `VIBIZ_APP_KEY`:

```ts
// app/api/vibiz/webhook/route.ts
import { vibiz } from '@vibiz/app';

export async function POST(req: Request) {
  let event;
  try {
    event = await vibiz.webhooks.receive(req);
  } catch {
    return new Response('bad signature', { status: 400 });
  }

  switch (event.type) {
    case 'payment.succeeded':
      // Fulfill one-time purchase: event.data.object
      break;
    case 'subscription.created':
    case 'subscription.updated':
      // Provision user subscription tier
      break;
    case 'subscription.canceled':
      // Revoke user access
      break;
  }

  return new Response('ok');
}
```

Events are retried with exponential backoff for up to 3 days if your handler returns a non-2xx status code or times out after 10 seconds. Always deduplicate processing on `event.id`. More details can be found in our [Webhooks documentation](https://thelastapi.dev/docs/guides/webhooks).

## Pricing, holds, and withdrawing money to your bank

Fees are deducted on each transaction, leaving the net amount in your project balance. There are no setup fees, monthly minimums, or withdrawal fees.

| Fee item | Cost | Details |
| --- | --- | --- |
| Card processing | 2.9% + 30¢ | Per payment for most US cards, deducted automatically |
| thelastapi platform fee | 2.0% (200 bps) | Taken as platform fee |
| Dispute fee | $15.00 | Taken upon dispute opening; refunded if won |
| Refunds | Disputed/refunded amount | Card processing and platform fees are not returned |
| Withdrawals | $0.00 | Free to withdraw to supported bank accounts |

On a $100.00 transaction, card processing is $3.20 and the platform fee is $2.00, depositing $94.80 net into your balance. You can query live fees at any time:

```bash
curl https://thelastapi.dev/v1/projects/prj_123/payments \
  -H "Authorization: Bearer $VIBIZ_API_KEY"
```

### Withdrawing funds

When you want to withdraw your available balance:

1. **Verify identity once:** The project owner opens the console, navigates to **Payments ▸ Get paid**, and inputs their personal identity details and bank account. Supported countries include the US, Canada, the UK, the EEA, and Switzerland.
2. **Execute withdrawal:** Once verification moves to `ready`, withdraw via the console or run:

```bash
vibiz payments withdraw
```

Withdrawing transfers all available funds past the 7-day hold period to your bank. The detailed financial model is documented in [Payments: how money moves](https://thelastapi.dev/docs/guides/payments).

To get started, explore the core [Payments reference](https://thelastapi.dev/docs/payments) or initialize your project with `vibiz init "My Project"`.

## Frequently asked questions

### Do I need to submit an ID or connect a bank account before I can start charging customers?

No, you can accept live card payments immediately when your project is created. Identity verification and bank account details are only required when the project owner initiates a withdrawal.

### What statement descriptor will my buyers see on their card statements?

Buyers will see `VIBIZ, INC* <APP>` by default. You can customize the suffix with a 1–10 character alphanumeric string (A–Z, 0–9, space, `.`, `-`) containing at least one letter.

### How long does it take for customer payments to become available for withdrawal?

Live payments are held as pending for 7 days before becoming available to withdraw. In the development environment, there is no hold period.

### Which countries are supported for bank account payouts?

Bank payouts are currently supported for project owners in the United States, Canada, the United Kingdom, the European Economic Area (EEA), and Switzerland.

---

Published 2026-11-15 · https://thelastapi.dev/blog/take-payments-without-merchant-account
