thelastapi
Get started free

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.

On this page 7 sections

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 before launching.

The balance is always maintained in USD. If you 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:

Terminal
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:

Terminal
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:

Terminal
vibiz payments simulate payment --dev
vibiz payments list --dev

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

Terminal
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_…):

Terminal
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.

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:

Terminal
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:

TypeScript
'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:

TypeScript
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.

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:

Terminal
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:

TypeScript
// 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.

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 itemCostDetails
Card processing2.9% + 30¢Per payment for most US cards, deducted automatically
thelastapi platform fee2.0% (200 bps)Taken as platform fee
Dispute fee$15.00Taken upon dispute opening; refunded if won
RefundsDisputed/refunded amountCard processing and platform fees are not returned
Withdrawals$0.00Free 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:

Terminal
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:
Terminal
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.

To get started, explore the core Payments reference 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.