How do I add payments to a Lovable app without Stripe?
The problem“I live in a non-Eu country that is not supported by Stripe, Plaid, or other providers that I checked." (a Bubble builder, Bubble forum, February 2022, still unanswered)”
To add payments to a Lovable app without Stripe, first try Paddle, Lovable's other built-in provider, which does not list N. Macedonia, Serbia or Pakistan as unsupported. If Paddle does not approve you, sell through a merchant of record that accepts your country, and let a small edge function in your Lovable backend unlock paying users from a signed webhook. Lovable can write that function from one prompt.
What payment providers does Lovable support?
Lovable's docs say: "Built-in payments are currently powered by two providers: Paddle and Stripe", and "Stripe and Paddle are the only payment providers with built-in support" (Lovable, Add payments to your app). For any other provider, Lovable can "integrate another provider's API through backend edge functions with your own account and API keys", but that is custom code you maintain and "it is not officially supported".
Three details matter if you sell from outside Stripe's countries:
- Stripe asks where your business is registered. Lovable's setup form asks for the country "where your business is registered". A personal address abroad does not change that.
- Managed Payments is Stripe's product, not Lovable's. It makes Stripe the seller and handles tax, and Lovable notes it "is available in fewer countries than Stripe's standard payment processing". Stripe lists 37 business locations: the US, Canada, all 27 EU countries, the UK, Norway, Switzerland, Liechtenstein, Australia, Hong Kong, Japan and Singapore (Stripe, Managed Payments eligibility). It also excludes professional services such as consulting, design or development.
- Paddle is the built-in option most people skip. Paddle "works with software businesses anywhere in the world" except the countries on its list (Paddle, supported countries). N. Macedonia, Serbia and Pakistan are not on that list. Lovable quotes Paddle at 5.0% + 50¢ per transaction.
| Your country | Stripe account | Stripe Managed Payments | Paddle (built into Lovable) | AgentaOS payout |
|---|---|---|---|---|
| N. Macedonia | Not listed | Not listed | Not on unsupported list | Yes, EUR or USD |
| Serbia | Not listed | Not listed | Not on unsupported list | Yes, EUR or USD |
| Pakistan | Not listed | Not listed | Not on unsupported list | Yes, USD |
Sources: Stripe global availability · Stripe Managed Payments eligibility · Paddle supported countries · AgentaOS payouts: N. Macedonia, Serbia, Pakistan. "Not on unsupported list" means Paddle does not exclude the country; Paddle still reviews each account.
Which route fits my Lovable app?
| Lovable + Stripe | Lovable + Paddle | Merchant of record + webhook (AgentaOS) | Company abroad + Stripe | |
|---|---|---|---|---|
| Works for a seller in N. Macedonia, Serbia or Pakistan | No | Check with Paddle (table above) | Yes, individuals and companies | Yes, once the company exists |
| Built into Lovable | Yes | Yes | No, you prompt Lovable to build it | Yes |
| Who handles VAT for buyers abroad | You, or Stripe with Managed Payments | Paddle, as merchant of record | AgentaOS, as the official seller | You, or Stripe with Managed Payments |
| Code you maintain | None beyond what Lovable generates | None beyond what Lovable generates | Two edge functions | None beyond what Lovable generates |
| Fee per card sale | Stripe's standard rates | 5.0% + 50¢ (per Lovable's docs) | 4.5% + €0.50; 6.0% + €0.50 for cards issued outside the EEA | Stripe's standard rates |
Fees: Lovable payments docs · AgentaOS pricing docs. Open Stripe's pricing and Paddle's pricing for their current rates.
Honestly: if Stripe takes you, use Lovable's built-in Stripe flow. If not, try Paddle inside Lovable first; it costs you no code. AgentaOS fits if Paddle does not approve you, if you sell services or packages, or if you want payouts to your own bank in 86 countries as an individual. A company abroad works too, but adds a company to run.
How do I set it up, step by step?
- Check your country. Open Stripe's list. If you are on it, ask Lovable for payments and pick Stripe. You can stop here.
- Try Paddle inside Lovable. Ask Lovable for a pricing page and choose Paddle. If Paddle approves your account, you are done without code.
- Make sure users sign in. Paid access needs to know who paid. Your Lovable app needs sign-in and a `profiles` table with an `is_pro` flag.
- Create your plan in AgentaOS. Make a free account, stay in test mode, create the product (monthly, yearly or one-time) and copy the plan's link ID (paywall demo).
- Prompt Lovable to build two functions. One creates a checkout for the signed-in user. One receives the webhook and sets `is_pro`. Use the prompt below.
- Add the secrets and the webhook URL. Store your API key, webhook signing secret and link ID as backend secrets. In AgentaOS, add the webhook function's URL and copy the signing secret from Settings, Developers, Webhooks (webhooks docs).
- Test, then go live. Pay once with a test card, check that `is_pro` turns on, cancel and check that it turns off. Then switch to your live key.
What prompt do I give Lovable?
Paste this into your Lovable project chat. It names only documented AgentaOS calls, so Lovable does not have to guess.
> Add a Pro plan paid through AgentaOS (not Stripe, not Paddle). Docs: https://docs.agentaos.ai/sdk/paywall-for-logged-in-users.md and https://docs.agentaos.ai/payments/webhooks.md > 1. Add `is_pro` (boolean, default false) and `subscription_id` (text) to the `profiles` table. Users must not be able to update these columns themselves. > 2. Create an edge function `create-checkout`. It reads the signed-in user, calls `agentaos.checkouts.create({ linkId, buyerEmail, metadata: { customerId: user.id }, successUrl, cancelUrl })` from the npm package `@agentaos/pay`, and returns `checkout.checkoutUrl`. The Upgrade button calls it and redirects there. > 3. Create an edge function `agentaos-webhook` that accepts calls without a user login. Read the raw body with `req.text()` and verify it with `agentaos.webhooks.verify(rawBody, X-AgentaOS-Signature header, AGENTAOS_WEBHOOK_SECRET)`. Return 400 if it throws. > 4. On `checkout.session.completed`, set `is_pro = true` and `subscription_id = event.data.metadata.subscriptionId` for the profile whose id is `event.data.metadata.customerId`. On `subscription.canceled`, set `is_pro = false` where `subscription_id = event.data.id`. > 5. Ask me for the secrets `AGENTAOS_API_KEY`, `AGENTAOS_WEBHOOK_SECRET` and `AGENTAOS_PRO_LINK_ID`. Show Pro features only when `is_pro` is true in the database, never because of the success page URL.
What does the code look like?
A short, generic sketch of the webhook function for a Lovable app on Supabase. The AgentaOS calls follow the webhooks docs, event reference and paywall demo; the `profiles` table is yours.
// supabase/functions/agentaos-webhook/index.ts
// Deploy with JWT verification off: AgentaOS calls this, not a signed-in user.
import { createClient } from 'npm:@supabase/supabase-js@2';
import { AgentaOS, WebhookVerificationError } from 'npm:@agentaos/pay';
const agentaos = new AgentaOS(Deno.env.get('AGENTAOS_API_KEY')!);
const db = createClient(
Deno.env.get('SUPABASE_URL')!,
Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!,
);
Deno.serve(async (req) => {
const rawBody = await req.text(); // raw text: parsed JSON fails verification
let event;
try {
event = agentaos.webhooks.verify(
rawBody,
req.headers.get('x-agentaos-signature') ?? '',
Deno.env.get('AGENTAOS_WEBHOOK_SECRET')!,
);
} catch (err) {
if (err instanceof WebhookVerificationError) return new Response('invalid', { status: 400 });
throw err;
}
if (event.type === 'checkout.session.completed') {
const { customerId, subscriptionId } = event.data.metadata ?? {};
if (typeof customerId === 'string') {
await db.from('profiles')
.update({ is_pro: true, subscription_id: subscriptionId ?? null })
.eq('id', customerId);
}
}
if (event.type === 'subscription.canceled') {
await db.from('profiles').update({ is_pro: false }).eq('subscription_id', event.data.id);
}
return new Response('ok', { status: 200 });
});Webhooks are signed with HMAC-SHA256 in the `X-AgentaOS-Signature` header, events older than 5 minutes are rejected, and failed deliveries are retried up to 3 attempts in total (webhooks docs). Renewals do not carry your `customerId`; match them by `subscriptionId`, which the first checkout event also carries (event reference). Do not give signed-in users the plan's shared payment link: it carries no `metadata`, so your webhook cannot tell who paid. Supabase Edge Functions run on Deno and load the SDK with the `npm:` prefix; we tested `webhooks.verify` from `@agentaos/pay` 2.6.0 on Deno 2.9 on 6 November 2026: a signed event verifies and a tampered signature is rejected. Still send one test event from your dashboard before you go live.
Example: a €19 monthly plan, paid by card
| EEA card | Card issued outside the EEA | |
|---|---|---|
| Buyer pays | €19.00 | €19.00 |
| AgentaOS card fee | 4.5% + €0.50 = −€1.36 | 6.0% + €0.50 = −€1.64 |
| After the card fee | €17.64 | €17.36 |
Rates from AgentaOS pricing docs. Try your own numbers in the payout calculator.
What about Bubble, without Stripe?
Bubble's payment guides use Stripe in every example because it is "the official plugin with the most extensive range of features" (Bubble manual, eCommerce and payments). Without Stripe, you can wire a merchant of record with no code, using two Bubble features:
- Create the checkout with the API Connector. Add a call: `POST https://api.agentaos.ai/api/v1/gateway/sessions`, header `x-api-key` with your secret key (keep it private), body with `linkId`, `buyerEmail`, `successUrl` and `metadata` holding the current user's unique ID. Use it as an action, then "Open an external website" with the returned `checkoutUrl` (create a checkout).
- Receive the webhook with an API workflow. Enable the Workflow API in Settings, API, and create a public API workflow; Bubble's manual says API workflows let "your app respond to webhooks in other systems" (Bubble, Workflow API). Bubble cannot easily check an HMAC signature, so do what Bubble's own Stripe example does: take the ID from the webhook and fetch the record from the provider. Call `GET /gateway/sessions/{session_id}` with your key, and only when `status` is `completed`, set the user from `metadata` to paid (retrieve a checkout). Backend workflows may need a paid Bubble plan, so check yours first.
Checklist: before you charge in your Lovable or Bubble app
- ✓Country checked on Stripe's list, and on Stripe's Managed Payments list if you want Stripe as the seller
- ✓Paddle tried inside Lovable before any custom code
- ✓Users sign in, so you know who paid
- ✓`is_pro` flag users cannot edit themselves
- ✓Checkout created per user with their ID in `metadata`, not a shared link
- ✓Webhook verified on the raw body (Lovable) or confirmed by fetching the checkout (Bubble)
- ✓Cancellations lock the user again
- ✓Secrets in the backend, never in front-end code
- ✓A EUR or USD account at your bank
- ✓One test payment and one test cancel before going live
When is AgentaOS the wrong choice?
- Stripe or Paddle takes you. Both are built into Lovable and need no custom code. Use them.
- You want a native Lovable integration. AgentaOS has none. Lovable writes the two functions from your prompt, and you own that code.
- You want license keys. AgentaOS has none; your database stores who paid.
- You want tips or donations. Our Terms do not allow donations or sponsorships (Terms).
- You need all the cash on day one. New accounts start with up to 15% of each sale set aside for 120 days (Terms, section 9.2).
Where does AgentaOS fit?
If Stripe and Paddle will not take you, and your Lovable or Bubble app sells software, courses or fixed-price service packages, AgentaOS is the official seller of each sale. Buyers pay by card, AgentaOS handles VAT and invoices, and you get paid to your own bank. It pays out to 86 countries, accepts individuals, and needs no company abroad. Your app keeps the paywall logic.
Change how you sell. Grow revenue 4×.
Answer 3 questions and get a free audit of your price and checkout, from the founder. Free, in 2 working days.
Related questions
Does Lovable support payments without Stripe?
Yes. Lovable has two built-in providers, Stripe and Paddle. Any other provider works through edge functions that Lovable writes from your prompt, but Lovable says that custom code is not officially supported, so you maintain it.
Is Stripe Managed Payments available in N. Macedonia, Serbia or Pakistan?
No. Stripe's Managed Payments eligibility page lists 37 business locations, and none of these three is on it. Standard Stripe accounts are not available there either. Paddle, the other built-in Lovable provider, does not list them as unsupported.
Can I take payments in Bubble without Stripe?
Yes. Bubble's official plugin is Stripe, but the API Connector can create a checkout with another provider, and a public API workflow can receive its webhook. Confirm each payment by fetching the checkout from the provider before you unlock the user.
Does AgentaOS have a Lovable integration?
No native one. You prompt Lovable to build two edge functions: one creates an AgentaOS checkout for the signed-in user, one receives the signed webhook and marks the user as paid. The prompt and a code sketch are on this page.
What does AgentaOS charge per sale in a Lovable app?
4.5% + €0.50 per card payment, or 6.0% + €0.50 for cards issued outside the EEA, on the pay-as-you-go plan with no monthly fee. On a €19 sale with an EEA card, that is €1.36.
Know what to charge before you launch
Paste your product or store link. Pricing Intelligence tells you what to charge and how to package it. Free, no card.
€0 account, no cardSell as an individual or a company
Related
Sources: Lovable, Add payments to your app · Stripe, global availability · Stripe, Managed Payments eligibility · Paddle, supported countries · Bubble forum thread (Feb 2022) · Bubble manual, eCommerce and payments · Bubble manual, Workflow API · Bubble manual, Case: Stripe notifications · AgentaOS paywall demo · AgentaOS webhooks · AgentaOS webhook events · AgentaOS create a checkout · AgentaOS retrieve a checkout · AgentaOS pricing docs · AgentaOS Terms