Adding real payments to a Base44 app (3 insertion points, tested)

Disclosure up front: I'm Oded, co-founder of UniPaaS, the FCA-authorised Payment Institution (No. 929994) behind paas.build - so this is a vendor writing about his own product. That said, the three Base44 mechanics below are documented Base44 surfaces, and they work with any external payments API, not just ours.

The wall

Tell Base44 "add payments" and it installs Stripe or Base44 Payments (powered by Wix), plus Tranzila/Max for Israel. Both main options are solid if you qualify: Stripe is excellent infrastructure with first-class docs, and the Wix-powered option is native to the platform.

The fine print is where builders hit a wall:

• Stripe live mode needs verified business and banking information before you can take a real payment.
• Base44 Payments requires "a business and bank account based in one of the supported countries" (their docs).
• The top payments request on Base44's own feedback board is "a way to setup other payment providers other than Stripe" - precisely because not every country is supported.
• Base44 webhooks only fire while someone is actively using your app, so 3am subscription renewals, retries and dunning silently don't run.

If you have a registered company in a supported country and mostly sell one-off purchases, use the built-in Stripe path. It's the smoothest. The rest of this post is for everyone else.

Base44 gives you three documented ways to wire in an external provider. I tested all three with paas.build. Here's each, and when it fits.

Insertion point 1: custom MCP connection (build-time)

In Base44: Settings → Account → MCP connections → Add custom MCP.

• Name: paas.build
• Server URL: https://paas.build/sse
• Auth: API key (your paas.build key)

That's the legacy SSE endpoint Base44's form takes; streamable HTTP lives at https://paas.build/mcp for agents that support it.

Base44's AI treats MCP connections as tools it can call when your request needs external data or actions. So in the editor chat you can say "use paas.build to create a live merchant account and a checkout" and it calls identify_business, go_live and create_checkout directly.

When it fits: provisioning the account and scaffolding the flow.

One real limit: Base44 runs MCP in the editor chat while you build, not at app runtime. Use it to open the account and generate the code, then one of the two runtime paths below to actually charge customers.

Insertion point 2: custom integration via OpenAPI (runtime)

A workspace admin registers the OpenAPI spec once: https://paas.build/openapi.json. Your API key is stored as an encrypted workspace secret, and your app calls the integration at runtime:

const { shortLink } = await base44.integrations.custom.call(
  "paasbuild",
  "createCheckout",
  { vendorId, amount: 29, currency: "GBP" }
);

When it fits: you want runtime charging without writing server code, and you're fine with a workspace admin owning the setup. It's the cleanest separation of secrets from app code.

Insertion point 3: backend function (runtime, universal)

Base44 backend functions run on the server, so secrets live in environment variables and you can fetch any external API:

// Base44 backend function
export default async function createCheckout({ amount }) {
  const r = await fetch("https://paas.build/api/checkout", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({
      vendorId: Deno.env.get("PAAS_VENDOR_ID"),
      amount,
      currency: "GBP"
    })
  });
  return await r.json(); // { shortLink, sessionToken }
}

When it fits: you want full control - custom logic around the charge, your own error handling, no dependency on a workspace admin. This is the path I'd default to for anything beyond a demo.

Why bother: the no-company, unsupported-country wedge

The reason to reach past the built-ins at all:

• No company needed. paas.build uses progressive KYB: a real merchant account (sandbox and production keys) the same session, individuals and sole traders included, live immediately with a cap of roughly £1,500 while verification completes in the background.
• Renewals actually run. You're the merchant on rails that run 24/7 server-side, so recurring billing, failed-payment retries and dunning don't depend on someone having your app open.
• Pricing at small tickets. 3.9% flat, no fixed fee. On a $9 subscription that's $0.35, versus $0.95 under the 5% + $0.50 pattern you'll see at typical Merchant-of-Record providers - an effective 10.6%.

Honest limitations

• UK, EU and US only on the merchant side. Buyers can pay from anywhere, but if you as the builder are registered outside those regions, paas.build does not unblock you, and that Base44 feedback-board request stays open for you.
• Tax is yours. You stay the seller of record, so VAT and sales tax are your responsibility. If you want tax handled for you globally, a Merchant of Record is the right category instead.
• The cap is real until verification completes. Plan for it if you expect volume on day one.
• MCP is build-time only. That's Base44's design, not a provider quirk. Don't plan runtime charging through it.

Pick insertion point 1 to get an account and scaffold, then 2 or 3 to charge. The full recipe with the same endpoints lives at https://paas.build/base44.