Payment Gateways

Connect Stripe or Paddle to your team and ship apps that take real payments, with a one-click switch between test and live mode

StackMivo can build apps that take real payments. Connect a payment gateway once at the team level, and every project you generate gets a working checkout flow and webhooks wired up automatically.

Stripe and Paddle are fully supported today. PayPal, Razorpay, Adyen, Square, Braintree, Lemon Squeezy, Mollie, Mercado Pago, Paystack, Klarna, Komoju, and Polar are listed as Coming Soon.

Connections are per team, not per user. Switching the active team in the IDE switches which payment account future generations will use.

A team can use only one payment gateway at a time. If Stripe is connected and you connect Paddle (or vice versa), StackMivo asks for confirmation and disconnects the other gateway. Projects already built with the previous gateway keep using it; only new builds use the new one.

Connecting Stripe

Step 1: Open the Payment Gateways page

In the sidebar, click Payment Gateways. You'll see a searchable grid of every supported provider. Stripe and Paddle show a Connect button; unimplemented providers show Coming Soon.

Click the Stripe card to open its detail page.

Step 2: Paste your Stripe secret keys

You'll be asked for:

Field	Required	Format
Test secret key	Yes	Must start with `sk_test_`
Live secret key	No (but required to go live later)	Must start with `sk_live_`

You can find both keys in your Stripe Dashboard under Developers → API keys.

Only team owners can connect or disconnect a payment gateway. Keys are stored encrypted and are never exposed to the AI agent or to clients. They only travel server-to-server when needed.

Step 3: Save

Click Connect. StackMivo validates the key against Stripe and, on success, shows your connected account's name (or email, or account ID) along with a Connected badge.

You don't need to provide a webhook signing secret. StackMivo registers webhooks automatically per project (see below).

Connecting Paddle

Paddle works as a merchant of record: it handles tax and compliance for you, and supports one-time payments, subscriptions, and Paddle-hosted checkout. The connection flow mirrors Stripe's.

Step 1: Open the Paddle detail page

On the Payment Gateways page, click the Paddle card.

Step 2: Paste your Paddle API keys

Field	Required	Format
Sandbox API Key	Yes	Must start with `pdl_sdbx_apikey_`
Live API Key	No (but required to take real payments later)	Must start with `pdl_live_apikey_`

In the Paddle dashboard, open Developer tools → Authentication and create an API key.

Unlike Stripe, Paddle's sandbox and live environments are separate accounts with separate logins and separate API keys. Create the key in the matching environment: sandbox keys at sandbox-vendors.paddle.com, live keys at vendors.paddle.com.

Step 3: Save

Click Connect. Each key is verified against the Paddle API before it's saved; a bad key is rejected immediately. New connections start in test (sandbox) mode.

As with Stripe, you don't provide webhook signing secrets — StackMivo registers a webhook per project automatically and stores the returned signing secret on the connection.

For hosted checkout, set a Default payment link under Checkout settings in your Paddle dashboard, so generated apps can redirect customers to a Paddle-hosted checkout page.

What happens when you generate a project

Once your team has a connected gateway, every new project the AI generates gets payments wired up automatically. You don't need to ask for it in the prompt. StackMivo detects payment-style apps and sets them up.

With Stripe connected, you'll find the following in your generated project:

Routes: /checkout, /payments/success, /payments/cancel, and /webhooks/stripe
Controllers: a checkout controller and a webhook controller with HMAC signature verification
Migrations: stripe_events and stripe_subscriptions tables (run automatically)
Config: config/stripe.php exposing mode, key, secret, webhook secret, and currency
Environment variables: STRIPE_KEY, STRIPE_SECRET, STRIPE_WEBHOOK_SECRET, STRIPE_MODE are written to your project's .env
A registered webhook in your Stripe account, pointing to your project's public URL and listening for the events you'd typically want (checkout.session.completed, customer.subscription.*, invoice.paid, invoice.payment_failed)

With Paddle connected, the project gets the equivalent Paddle scaffolding:

Controllers: PaddleCheckoutController and PaddleWebhookController with signature verification
Migrations: paddle_events and paddle_subscriptions tables (run automatically)
Config and routes: config/paddle.php and routes/paddle.php
Environment variables: PADDLE_API_KEY, PADDLE_WEBHOOK_SECRET, PADDLE_ENV, PADDLE_MODE are written to your project's .env (PADDLE_ENV is sandbox in test mode and production in live mode)
A registered webhook in your Paddle account pointing to your project's public URL

Two app shapes

Shape	What it looks like	How payments work
Cart	One-off purchases (e.g. a shop, a menu, a hotel booking)	Each request creates a Stripe Checkout Session on the fly using your app's own products in the database. No pre-created Stripe products needed.
Subscription	Recurring plans (e.g. SaaS tiers)	The AI creates real Products, Prices, and Payment Links in your Stripe account during generation, and references the resulting `buy.stripe.com` URLs in your code.

StackMivo picks the right shape based on what you asked for. Both start in test mode by default. You can take real payments only after going live.

Switching between test and live mode

There are two places mode is controlled:

Per connection — on the gateway's detail page, Switch to Test / Switch to Live buttons flip which environment new builds use. Each button appears only once the corresponding key is stored. This is how you switch modes for Paddle (test maps to Paddle's sandbox account, live to the production account).
Per project (Stripe only) — the Go Live toggle inside the IDE, described below. Different Stripe projects on the same team can be in different modes at the same time.

The Go Live toggle (Stripe)

Every payment-enabled Stripe project starts in test mode (amber dot, label Go Live). When you're ready to take real payments, flip the switch from inside the IDE.

Where to find it

Open the project in the IDE. The Go Live button sits in the workbench toolbar.

The button only appears when the project actually has payment integration. Projects without payments never see the button.

Switching to live

Click Go Live
Read the confirmation modal: it explains what will happen and reminds you that real charges will start once active
Click Confirm

For cart apps, the switch is instant. Your project's .env is rewritten with your live keys, the live webhook is registered, and the button flips to a green dot reading Switch to test.

For subscription apps, the same env/webhook swap happens, plus a regeneration prompt is automatically sent to the chat panel. The AI then recreates the products, prices, and payment links inside your live Stripe account so the app's catalogue exists there too. You don't need to click anything else, just watch the chat finish.

The Go Live button is disabled until you've added a sk_live_ key to your team's Stripe connection. The tooltip points you back to Payment Gateways if it's missing.

Switching back to test

Click Switch to test. The same flow runs in reverse with a lighter confirmation (no risk of real charges). Different projects on the same team can be in different modes at the same time; switching one doesn't touch the others.

Pre-conditions for going live

Before flipping a project live, make sure:

A live secret key (sk_live_...) is saved on your team's Stripe connection
The project's container is running, so configuration changes can be applied
For subscription apps, you're comfortable with the AI recreating your product/price catalogue in the live Stripe account

Reversibility and safety

The Go Live switch is fully reversible in both directions.
Cart-mode switches don't touch your data or migrations.
Subscription-mode switches only rewrite the source files that hold buy.stripe.com URLs (controllers and seeders). Existing customer subscriptions in Stripe are not migrated automatically. Moving live customers between Stripe accounts is a manual operation in the Stripe Dashboard and isn't something StackMivo does for you.
All credentials are stored encrypted at rest. The AI agent never sees your raw keys directly.

Always run a real test payment in test mode before going live. Use Stripe's test card 4242 4242 4242 4242 with any future expiry and any CVC. For Paddle, run the payment against your sandbox account using Paddle's test cards.

Disconnecting a gateway

On the gateway's detail page, click Disconnect to remove the connection and its stored credentials. New project generations on that team will no longer include payment scaffolding, but existing projects keep working: their .env keys and code remain in place until you change them.

If you re-connect later with a different account, future projects will use the new account; existing projects keep pointing to their original keys until you regenerate or edit them.

On this page