---
title: "Lovable Pricing (Nov 2026): Plans, Credits and Real Cost | Superapp"
description: "Lovable pricing for November 2026: Pro from $25, Business from $50, what credits buy, Cloud and AI costs, and the hidden charges real users report."
image: https://superapp.dev/superapp-logo.png
canonical_url: https://superapp.dev/blog/lovable-pricing
md_url: https://superapp.dev/blog/lovable-pricing.md
---
---

## meta-title: "Lovable Pricing (Nov 2026): Plans, Credits and Real Cost"  
meta-description: "Lovable pricing for November 2026: Pro from $25, Business from $50, what credits buy, Cloud and AI costs, and the hidden charges real users report."  
h1-title: "Lovable Pricing (November 2026): Plans, Credits and Real Cost"  
description: "Every Lovable plan and credit tier, what credits buy across building, Cloud and AI, the costs real users run into beyond the sticker price, and how Lovable compares to Superapp, Base44 and Replit on price."  
tags: ["Lovable", "Lovable pricing", "Lovable credits", "Lovable Cloud", "AI app builder pricing", "vibe coding"]

## Lovable Pricing: The Short Answer

Lovable has a free plan, Pro from $25 a month and Business from $50 a month, each sold in credit tiers from 100 to 10,000 credits, plus custom Enterprise pricing. Annual billing gives you two months free. Since mid-2026, one credit balance pays for everything: building with the AI, chatting, hosting your app's backend on Lovable Cloud and powering AI features in your published app. That makes the plan price predictable but the credit burn less so. Below you will find every plan and tier, what credits actually buy, the hidden costs real users report, and how Lovable's pricing compares to Superapp, Base44 and Replit.

> **Quick answer: how much does Lovable cost?** As of November 2026, Lovable is free with 5 build credits a day (up to 30 a month), Pro costs from $25 a month for 100 credits and Business from $50 a month for 100 credits, with tiers up to 10,000 credits and two months free on annual billing. Every plan adds 5 daily build credits plus small monthly grants for Cloud and AI. Prompts cost from about 0.5 to 2 credits, more on large projects, and the same balance pays for hosting and AI in your app. Unused credits roll over for two months but freeze when you cancel, and fees are non-refundable. For a native iPhone app rather than a web app, a native-Swift builder like Superapp is the more direct route.

Prices below were checked on November 3, 2026 against [Lovable's subscription plans](https://docs.lovable.dev/introduction/subscription-plans) and [credits documentation](https://docs.lovable.dev/introduction/credits-and-usage). User stories come from public reviews on [Trustpilot](https://www.trustpilot.com/review/lovable.dev) and [Product Hunt](https://www.producthunt.com/products/lovable/reviews).

## How much does each Lovable plan cost?

Lovable sells Pro and Business in monthly credit tiers. The entry tier of each is the price most people quote.

| Plan | Entry price, monthly | Entry price, yearly | Monthly credits | Extra included | Built for |
| --- | --- | --- | --- | --- | --- |
| Free | $0 | $0 | None | 5 build credits a day, up to 30 a month | Trying Lovable and small projects |
| Pro | $25 | $250 ($21/mo) | From 100 | 5 daily build credits, no monthly cap | Individuals and small teams |
| Business | $50 | $500 ($42/mo) | From 100 | 5 daily build credits, governance features | Departments needing SSO and controls |
| Enterprise | Custom | Custom | Volume-based | Contract terms | Large organizations |

All of Free, Pro and Business also get a daily chat allowance, a 20-credit monthly Cloud grant, a 4-credit monthly AI grant and a 1-credit connector grant. Lovable describes those monthly grants as temporary and subject to change ([credits docs](https://docs.lovable.dev/introduction/credits-and-usage)).

Some third-party guides still describe a "Starter $25, Pro $50" lineup. That is out of date: today Pro starts at $25 and Business at $50.

### Pro credit tiers

| Monthly credits | Monthly billing | Annual billing |
| --- | --- | --- |
| 100 | $25 | $250 ($21/mo) |
| 200 | $50 | $500 ($42/mo) |
| 400 | $100 | $1,000 ($84/mo) |
| 800 | $200 | $2,000 ($167/mo) |
| 1,200 | $294 | $2,940 ($245/mo) |
| 2,000 | $480 | $4,800 ($400/mo) |
| 3,000 | $705 | $7,050 ($588/mo) |
| 4,000 | $920 | $9,200 ($767/mo) |
| 5,000 | $1,125 | $11,250 ($938/mo) |
| 7,500 | $1,688 | $16,880 ($1,407/mo) |
| 10,000 | $2,250 | $22,500 ($1,875/mo) |

### Business credit tiers

| Monthly credits | Monthly billing | Annual billing |
| --- | --- | --- |
| 100 | $50 | $500 ($42/mo) |
| 200 | $100 | $1,000 ($84/mo) |
| 400 | $200 | $2,000 ($167/mo) |
| 800 | $400 | $4,000 ($334/mo) |
| 1,200 | $588 | $5,880 ($490/mo) |
| 2,000 | $960 | $9,600 ($800/mo) |
| 3,000 | $1,410 | $14,100 ($1,175/mo) |
| 4,000 | $1,840 | $18,400 ($1,534/mo) |
| 5,000 | $2,250 | $22,500 ($1,875/mo) |
| 7,500 | $3,300 | $33,000 ($2,750/mo) |
| 10,000 | $4,300 | $43,000 ($3,584/mo) |

Source: [Lovable subscription plans](https://docs.lovable.dev/introduction/subscription-plans). Business costs twice as much per credit as Pro at every tier; you pay for governance features, not for more building.

## What does each Lovable plan include?

The jump from Free to Pro unlocks the things most real projects need: editing and downloading code, custom domains and rollover. Business adds team governance.

| Feature | Free | Pro | Business | Enterprise |
| --- | --- | --- | --- | --- |
| Daily build credits | 5, up to 30 a month | 5, no monthly cap | 5, no monthly cap | None |
| Monthly subscription credits | None | From 100 | From 100 | Volume-based |
| Monthly Cloud and AI grants | 20 and 4 credits | 20 and 4 credits | 20 and 4 credits | None |
| Credit rollover | No | Yes | Yes | No |
| Top-ups and auto top-up | No | Yes | Yes | No |
| Usage limits and alerts | No | Yes | Yes | Yes |
| Git sync | Yes | Yes | Yes | Yes |
| Edit and download code | No | Yes | Yes | Yes |
| Custom domains | No | Yes | Yes | Yes |
| Remove "Edit with Lovable" badge | No | Yes | Yes | Yes |
| Larger database instances | No, Tiny only | Yes | Yes | Yes |
| SSO and role-based access | No | No | Yes | Yes |
| Security center | No | No | Yes | Yes |
| Scheduled security scans and audit logs | No | No | No | Yes |
| Support | Community | Email | Priority | Dedicated |

Sources: [subscription plans](https://docs.lovable.dev/introduction/subscription-plans), [database performance](https://docs.lovable.dev/features/database-performance).

## How do Lovable credits work?

Lovable uses one credit balance for five kinds of usage: building, chatting, hosting and running your app's backend (Cloud), AI features in your deployed app, and some managed connectors. The balance is fed from two sources ([credits docs](https://docs.lovable.dev/introduction/credits-and-usage)).

Usage-specific grants are spent first: the daily chat allowance, 5 daily build credits, and the monthly Cloud, AI and connector grants. None of them roll over. General credits are spent next, starting with whichever expire soonest: monthly plan credits, top-ups and bonus credits.

The rules that matter for your bill:

- Monthly plan credits roll over while your subscription is active, but expire 2 months after they were issued on monthly plans, or 1 month after the annual period ends on annual plans.
 - Top-up credits last 12 months.
 - When a grant runs out, the usage it covered draws from your general credits, so a busy backend can quietly eat your building budget.
 - Each plan has a "plan credit rate": $0.25 per credit on Pro and $0.50 on Business. Lovable used it to convert old dollar Cloud and AI balances into credits.

Until mid-2026, Cloud hosting and AI gateway usage had separate dollar balances. Lovable moved everything onto one credit balance, starting with some workspaces on June 1, 2026. Lovable says the cost of running projects did not change, only the unit, but the change is why some users suddenly saw hosting draw from the credits they had planned for building.

## What do Lovable credits buy?

A typical prompt costs between half a credit and two credits, but costs scale with how much work the AI does. Lovable publishes these examples for Build mode:

| Prompt | Work done | Credits |
| --- | --- | --- |
| Make the button gray | Changes button styles | 0.50 |
| Remove the footer | Removes the footer component | 0.90 |
| Add authentication | Adds login and authentication logic | 1.20 |
| Build a landing page with images | Landing page with generated images, theme and sections | 2.00 |
| Plan Mode message | Plans without changing code | 1, plus any subagent research |
| Goal run (/goal) | Keeps working until the goal is met | Noticeably more for the same work |

Source: [Lovable credits docs](https://docs.lovable.dev/introduction/credits-and-usage). These are illustrative; actual costs depend on your project.

Everything else on the balance is metered by usage:

| Meter | What drives the cost |
| --- | --- |
| Chat and Chat mode | Per-message price, usually a fraction of a credit, after the daily chat allowance |
| Database server | Instance size and how long it stays active |
| Database storage | How much data you store |
| Network | Data your app sends and receives |
| File storage | Uploaded and generated files, which keep costing even while paused |
| Compute | Backend code such as payments or emails |
| Realtime | Live updates such as chat or notifications |
| AI gateway | Model choice, input and output tokens, call volume |
| Managed connectors | Per-request rate on each connector's page |

Lovable does not publish credit rates for Cloud or database instances. The estimated monthly cost for each database size appears in the Manage instance dialog of each project, based on your last 30 days of usage ([database performance docs](https://docs.lovable.dev/features/database-performance)).

A Lovable credit is worth $0.25 at the Pro entry tier, $0.30 as a Pro top-up, and $0.50 at the Business entry tier. In dollar terms, a gray button costs about 13 cents on Pro and a landing page about 50 cents (our arithmetic).

## What does Lovable really charge for beyond the plan price?

Lovable is unusually transparent about its meters, but the plan price is still rarely the whole bill. These are the costs that come up most in user reviews.

| Hidden cost | What it is | Who pays it | How to limit it |
| --- | --- | --- | --- |
| Paying for AI mistakes | Prompts that fail, retry or break things still use credits | Everyone who builds | Revert, use Plan Mode, keep prompts narrow |
| Rising prompt costs | Long prompts and large projects cost several credits each | Projects that grow | Split work into small steps |
| Hosting and database | Cloud usage beyond the 20-credit grant draws from build credits | Apps with a backend | Pause unused backends, right-size the instance |
| AI features in your app | Model calls bill at provider rates through your credits | Apps with AI features | Use your own key via an edge function |
| Frozen credits | Unused plan credits freeze when you cancel | Anyone who downgrades | Use credits before cancelling |
| Non-refundable fees | Subscription fees and credits are non-refundable | Everyone | Start on the smallest tier |
| Business premium | Business credits cost twice as much as Pro | Teams needing SSO | Stay on Pro unless you need governance |
| Domains and outside services | Domain renewals, Apple and Google fees, Stripe | Apps that publish or sell | Add them to the budget |
| Security fixes | Fixing data exposure costs credits and time | Apps handling user data | Check access rules before launch |

The sections below cover each, with what Lovable's documentation says and what users report.

## What are real users paying on Lovable?

Lovable is the best-reviewed of the major AI app builders, at 4.2 out of 5 from 1,894 reviews on Trustpilot and 4.7 out of 5 from 212 reviews on Product Hunt as of November 2026. The stories below are a deliberate selection of cost-related reviews, so they over-represent unhappy users; most Lovable reviewers are satisfied. They are still the clearest picture of where Lovable bills surprise people.

| User and source | When | What they report | In their words |
| --- | --- | --- | --- |
| Morne Booysen, Product Hunt | Late 2025 | About $2,000 in year one on prompts and hosting | "lost lots of prompts due to a bug" |
| Maxprog, Product Hunt | 2026 | A 400-credit Pro plan lasted about two weeks | "credits are consumed quickly in real development work" |
| Mr W Hammond, Trustpilot | September 2026 | Storage used 70 credits a month of a 100-credit plan, on an unpublished app | "They recently updated how cloud storage works, to use your build credits" |
| sam smith, Trustpilot | October 2026 | Billing in pounds on a US card | "the foreign transaction fees came to nearly $100." |
| Marina, Trustpilot | September 2026 | 74.95 credits frozen and 31.95 expired after downgrading | "Paid credits are locked unless you pay again. Very disappointing!" |
| Jakov, Trustpilot | August 2026 | Prompts that once cost 0.5 to 2.5 credits now cost 5 to 10 | "Today you can spend 5-10 credits with one long input, which is just apsurd." |
| Ravi Shankar Mishra, Trustpilot | August 2026 | Work stopped mid-task until a paid top-up | "A single basic prompt burns 5 to 10 credits in one go" |
| Joy Ifeoma, Trustpilot | July 2026 | 10 credits to remove an app, 12 to remove a banner | "removing an app cost 10 credits" |
| Naomi Agosto, Trustpilot | September 2026 | Edits at 2 to 3 credits each; lost credits when she stopped paying | "all of my credits that accumulated are gone." |
| Alexey Utkin, Trustpilot | October 2026 | Ran out of credits on an unfinished template | "The credits ran out before I had a working result" |
| Douglas Carlson, Trustpilot | October 2026 | Starter credits used up during setup | "they gave me just a handful of credits which were quickly burned" |
| Bob Harvey, Trustpilot | July 2026 | Text edits and failed restores cost credits | "Now I can't even change text content without burning credits." |
| Connor R, Trustpilot | October 2026 | Daily credits run out before anything is done | "Good tool, BUT SO EXPENSIVE!" |
| Shar, Trustpilot | October 2026 | Even questions used credits | "you gotta keep buying credit to build" |
| Agency, Trustpilot | September 2026 | Repeated "Fix issue" attempts without a fix | "every additional attempt costs prompts/credits without actually resolving the problem." |

Sources: [Trustpilot](https://www.trustpilot.com/review/lovable.dev), [Product Hunt](https://www.producthunt.com/products/lovable/reviews).

The same review pages are full of the opposite experience. Calum wrote in September 2026, "Credit spend is sensible as well," and Kirsten Mckenzie called Lovable "very reasonably priced." Julia Carter went further: "Great value if it was twice the price." ITGN Games said, "Lovable made possible what I thought would cost me hundreds of dollars." The split is consistent: people building small sites and focused tools tend to find Lovable cheap; people iterating on large apps, or fighting a stubborn bug, find the credits go fast.

## Why do Lovable bills spike?

Most of the cost complaints trace back to six patterns.

| Pattern | What happens | What users report | Fix |
| --- | --- | --- | --- |
| Fix loops | The AI misses a bug and each retry costs credits | Agency's repeated "Fix issue" attempts; Juan's retried attempts | Revert to the last working version, then describe the bug once, precisely |
| Long prompts | Long inputs and broad requests cost several credits | Jakov's 5 to 10 credits per long input | Split work into short, single-purpose prompts |
| Large projects | More code means more context and more work per request | Kai Long: costs "climb quickly on larger projects" | Keep components small and focused |
| Backend running in the background | Cloud usage beyond the grant draws from build credits | Mr W Hammond's 70 credits a month on storage | Pause unused backends, delete unused files |
| Long-running agent work | One message can run for hours and cost tens of credits | Lovable added check-ins at 20 credits per message | Keep check-ins on; avoid /goal for open-ended tasks |
| Exploring instead of building | Questions and brainstorming in Build mode cost build credits | Shar: even asking a question used credits | Use Chat mode or Plan Mode to think, Build mode to change |

Lovable's own docs confirm the long-running case: a single Build mode message can run for up to 10 hours, and by default Lovable pauses to check in each time a message crosses 20 credits ([credits docs](https://docs.lovable.dev/introduction/credits-and-usage)). That is a useful guardrail, and also a sign of how much one message can cost: at the Pro rate, 20 credits is about $5.

## Do you pay for Lovable's AI mistakes?

Yes. Every Build mode message is charged on the work done, whether or not the result works, and Lovable's terms say subscription fees and credits are non-refundable except where the law requires otherwise ([Lovable FAQ](https://docs.lovable.dev/introduction/faq)). Stopping a request early charges for work completed so far; a request stopped before Lovable changes anything is free.

The pattern users describe is the same one seen on every AI builder: a bug appears, you ask the AI to fix it, the fix introduces another problem, and each round costs credits. Juan, a five-star reviewer, still mentioned "seeing my credit count go down just from retried attempts." On Product Hunt, Vasileios Tsipas asked Lovable to "consider how credits are charged especially for error fixing."

A case study published on DEV in October 2026 by Aakash Verma, the founder of a Lovable deployment service, put numbers on it: a founder on the 400-credit Pro tier used 412 credits in four weeks, about 90 on core features in the first week and about 260 on a single login bug over 11 days. At the Pro rate, that bug cost around $65, more than twice what the features cost (our arithmetic) ([DEV](https://dev.to/batmanofweb/lovable-pricing-where-the-credits-go-oa7)). The author runs a related paid service, so treat it as an illustration rather than independent data.

There is a fairer side. Lovable gives Pro and Business users 5 free build credits every day with no monthly cap, which covers many small fixes. Reverting to a previous version costs nothing, Plan Mode lets you diagnose for a fixed 1 credit per message, and each response shows its exact cost under "Credits used." Hanna B, a five-star reviewer, noted that Lovable creates more bugs than Cursor but still fixes them, and many reviewers say the daily credits are enough for steady progress.

## Does Lovable charge for hosting, the database and AI?

Yes, through the same credit balance. Publishing a frontend to a lovable.app address is free on every plan ([Lovable FAQ](https://docs.lovable.dev/introduction/faq)). The backend is where costs start: Lovable Cloud, the built-in database, authentication, storage and backend functions, is billed by usage in credits after the 20-credit monthly Cloud grant ([credits docs](https://docs.lovable.dev/introduction/credits-and-usage)). For a deeper look, see our guide to [Lovable Cloud costs](https://superapp.dev/blog/lovable-cloud-explained-costs-supabase-and-what-you-actually-own).

What drives Cloud cost:

- Database instance size and active time. Free projects run on the smallest instance, Tiny; paid plans can move up to Mini, Small, Medium, Large or X-Large, and larger sizes cost more credits per hour.
 - Stored data, files and network traffic. Uploaded files keep costing even while the backend is paused.
 - Background work. Scheduled jobs and frequent functions keep the backend busy.

Lovable automatically pauses inactive backends, and lets you pause one manually. When credits run out completely, the backend pauses too: your data is kept, but you cannot access or export it until the services restart ([out-of-credits docs](https://docs.lovable.dev/introduction/out-of-credits)).

The clearest hosting story in reviews is Mr W Hammond's. He wrote in September 2026 that after Lovable moved storage onto build credits, an app he had not even published was using 70 credits a month of his 100-credit plan. Mathieu, a French reviewer, made the same complaint in August: "credit drain , you will pay all daba base." Lovable replied to him: "Sorry the credit drain and database costs have soured" his experience.

Two ways to keep backend and AI costs off your Lovable balance:

- Connect your own Supabase project instead of Lovable Cloud. Supabase then bills the backend directly, with its own free tier, while Lovable credits still pay for building ([Supabase integration docs](https://docs.lovable.dev/integrations/supabase)).
 - For AI features, Lovable's built-in AI connector always bills your credits at provider rates and cannot use your own key. The workaround is to have Lovable call the provider from a backend function with your key stored as a secret, so the provider bills you directly ([AI docs](https://docs.lovable.dev/features/ai)).

## How a $25 month turns into $100: three illustrations

These are illustrations built from Lovable's published credit examples and the costs users report, not records of a specific account.

The careful builder. A freelancer builds a marketing site with a contact form on Pro 100. Most edits cost 0.5 to 1 credit, small fixes come out of the 5 daily credits, and the backend stays inside the 20-credit Cloud grant. Unused credits roll over to next month. Total: $25.

The growing app. A founder adds features to a three-month-old app with users and a database. Prompts now cost 3 to 5 credits each because the codebase is large, as reviewers describe, and the backend runs past its grant. Two weeks in, the 100 credits are gone, so they buy two 50-credit top-ups at $15 each. Total: $55, and the next month they move up to Pro 200 at $50.

The bug week. A builder hits a login bug that the AI keeps half-fixing, the pattern in the DEV case study. Over a week of retries, the bug alone consumes about 250 credits. On Pro 100, that means the plan plus five top-ups. Total: about $100, with nothing to show beyond the fix.

The difference is not the plan. It is project size, prompt length and whether you revert or keep retrying.

## What happens when you run out of Lovable credits?

Lovable stops rather than billing you overage, which is the main difference from Replit. What stops depends on which part of the balance ran out ([out-of-credits docs](https://docs.lovable.dev/introduction/out-of-credits)):

| What | When credits run out |
| --- | --- |
| Building | New messages open a top-up or upgrade dialog; work in progress pauses, not discarded |
| Chat | Continues on the daily chat allowance, then pauses until it resets |
| AI features in your published app | Fail once the AI grant and general credits are gone, with no message of their own |
| Cloud backend | Pauses; data is kept but cannot be accessed or exported until restarted |
| Published site | Keeps serving, but anything that needs the backend or AI stops responding |
| Subscription | Unaffected; plan credits refill next billing period |

There is no grace period. Lovable shows a run-out estimate on Pro and Business, banners when Cloud, AI or workspace credits run low, and a warning banner before projects pause for Cloud.

To keep going, Pro and Business admins can buy top-ups:

| Plan | Top-up price | Per credit | Validity |
| --- | --- | --- | --- |
| Pro | $15 for 50 credits | $0.30 | 12 months |
| Business | $30 for 50 credits | $0.60 | 12 months |

Source: [Lovable top-up docs](https://docs.lovable.dev/introduction/credit-top-ups). Packs range from 50 to 10,000 credits. Free users cannot buy top-ups and must upgrade.

Auto top-up buys credits automatically when your balance falls to 25, 50 or 100 credits, with a monthly spend limit that defaults to 400 credits. Two details to know: if a card is declined, auto top-up does not retry for 7 days, which can leave a live backend paused; and upgrading from Pro to Business pauses auto top-up until you confirm, because the per-credit price doubles.

The practical consequence for a live app is that running out can take your backend offline even though your plan is paid. Ravi Shankar Mishra described work stopping mid-task until a paid top-up, and Alexey Utkin said credits ran out before he had a working result.

## What happens to your credits when you cancel Lovable?

They freeze. When you downgrade to Free, your plan stays active until the end of the billing period, then unused monthly and rollover credits are frozen and not refunded. They become usable again only if you upgrade before they expire. Top-up and bonus credits stay usable on Free until they expire ([manage subscription docs](https://docs.lovable.dev/introduction/manage-subscription)).

This is one of the most common complaints in recent reviews:

| User | When | What they report |
| --- | --- | --- |
| Marina | September 2026 | "Paid credits are locked unless you pay again. Very disappointing!" |
| Jagan Mohan Mathangi | September 2026 | "My credits had an expiry date of 2nd October 2026." Lost them after cancelling |
| Naomi Agosto | September 2026 | "all of my credits that accumulated are gone." |
| Richard Nagels | July 2026 | "I also lost access to the credits I am still paying for." |
| Gil | October 2026 | "You pay for credits, if you don't use them you lose them" |

Sources: [Trustpilot](https://www.trustpilot.com/review/lovable.dev).

Gil's complaint deserves context: on an active subscription, Lovable's plan credits roll over for two months, which is more generous than Base44 or Replit Core. The loss happens mainly when you stop paying or let credits pass their two-month expiry. If you are about to cancel, spend your plan credits first; buy top-ups only if you can use them within a year.

Your published apps stay live on Free. Lovable may unpublish an app only after 12 months or more with no visits, no owner login and no custom domain, and emails first.

## Can you get a refund from Lovable?

Generally no. Lovable's FAQ states: "Subscription fees and credits are non-refundable, except where the law requires a refund." Cancelling stops future charges but does not refund the current period, and frozen credits are not refunded ([Lovable FAQ](https://docs.lovable.dev/introduction/faq)). If you were charged in error, for example after cancelling, Lovable asks you to contact support with your workspace name and the charge.

In practice, outcomes vary by case:

| User | When | What happened |
| --- | --- | --- |
| Zen | October 2026 | "Lovable Refunded me under 5 days and didn't had any problem" |
| Inna Lisovenko | September 2026 | Refused at first under a rule about having used over half the credits; approved after about 3 days of persistence |
| Amir | August 2026 | A 50% discount offer led to an annual charge; "requested a refund, but they refused." |
| Brit V | August 2026 | Refund denied after documenting bugs; Lovable replied it had asked for a case review |
| Don Cox | September 2026 | Refund refused because the charge was outside the refundable time window |
| Allan Binu | October 2026 | "My request for goodwill credits has also gone unanswered." |

The pattern suggests support has some discretion, especially soon after a charge and before most credits are used. Ask quickly, include the workspace name and the charge, and do not spend the credits while you wait.

Two billing details worth checking before you pay. sam smith, a US user billed in pounds, said "the foreign transaction fees came to nearly $100" over several charges, so check the billing currency at checkout. And Amir's case shows that a discount shown for monthly billing may not apply the same way to annual, so read the checkout summary before confirming.

## Does security cost extra on Lovable?

Indirectly. Lovable apps store user data in a real database, and keeping it private depends on correct access rules. In May 2025, a vulnerability was published as CVE-2025-48757, rated 9.3 out of 10, describing insufficient row-level security in Lovable-generated apps through April 15, 2025, which could let unauthenticated attackers read or write database tables. Lovable disputes the CVE, saying each customer is responsible for protecting their application's data ([CVE record](https://cvemon.intruder.io/cves/CVE-2025-48757)).

The pricing angle is that security tooling sits on higher tiers. Business includes a security center and security insights; scheduled security scans and audit logs are Enterprise features ([subscription plans](https://docs.lovable.dev/introduction/subscription-plans)). On Pro, checking and fixing access rules is your job, and fixes cost credits like any other prompt. Don Cox, a September 2026 reviewer, said he abandoned his site over a security issue he could not get fixed, then was refused a refund. If your app holds personal or payment data, budget time and credits for a security review before launch.

## What does it cost to put a Lovable app on the App Store?

Superapp's $25 Pro plan builds a native Swift iPhone app and includes automated App Store publishing; Lovable, by its own documentation, does not build native mobile apps or publish to the stores directly. Lovable's docs describe a workaround: package the Lovable web app with a web-to-native wrapper, then submit it with Xcode for iOS or Android Studio for Android ([Lovable mobile docs](https://docs.lovable.dev/tips-tricks/mobile-store)).

That route adds costs on top of your Lovable plan: Apple's Developer Program at $99 a year, Google Play's $25 one-time fee, and whatever the wrapper service charges. Apple's guidelines also scrutinize apps that are thin wrappers around websites, so a wrapped Lovable app carries more review risk than a native one. For the full picture, see our guide on [whether Lovable can make mobile apps](https://superapp.dev/blog/can-lovable-make-mobile-apps-how-to-publish-a-lovable-app-to-the-app-store).

## Is the Lovable annual plan worth it?

Annual billing gives you two months free, a saving of about 17%, and your monthly credits are still issued monthly.

| Plan and tier | 12 months monthly | 12 months yearly | You save |
| --- | --- | --- | --- |
| Pro 100 | $300 | $250 | $50 |
| Pro 200 | $600 | $500 | $100 |
| Pro 400 | $1,200 | $1,000 | $200 |
| Business 100 | $600 | $500 | $100 |
| Business 400 | $2,400 | $2,000 | $400 |

Annual plans have a quirk in your favour: monthly credits issued during an annual plan stay valid until one month after the annual period ends, so heavy months can draw on lighter ones across the whole year. The risk is the non-refundable fee. Since credit needs change quickly as projects grow, a month or two on monthly billing is the safer way to find your tier.

## How much does a Lovable credit cost at each tier?

Lovable's per-credit price is flat within a plan, so bigger tiers do not buy cheaper credits until you reach 1,200 credits and above.

| Tier | Pro price per credit | Business price per credit |
| --- | --- | --- |
| 100 to 800 credits | $0.250 | $0.500 |
| 1,200 credits | $0.245 | $0.490 |
| 2,000 credits | $0.240 | $0.480 |
| 3,000 credits | $0.235 | $0.470 |
| 4,000 credits | $0.230 | $0.460 |
| 5,000 credits | $0.225 | $0.450 |
| 7,500 credits | $0.225 | $0.440 |
| 10,000 credits | $0.225 | $0.430 |
| Top-up | $0.300 | $0.600 |

Our arithmetic from Lovable's published monthly prices. Top-ups cost 20% more per credit than plan credits on Pro, so if you top up every month, moving up a tier is cheaper.

## How much does it cost to build an app on Lovable?

Lovable does not publish per-app costs, but its examples and users' reports give a working range. Each depends on scope and how much rework the AI needed.

| What was built | Reported or estimated credits | Approximate cost on Pro |
| --- | --- | --- |
| A small style change | 0.5 credits | About $0.13 |
| Adding login and authentication | 1.2 credits | About $0.30 |
| A landing page with images | 2 credits | About $0.50 |
| Removing an app or banner (user report) | 10 to 12 credits | About $2.50 to $3 |
| Core features of an app in one week (DEV case) | About 90 credits | About $23 |
| One stubborn login bug over 11 days (DEV case) | About 260 credits | About $65 |
| Heavy development for two weeks (Product Hunt user) | About 400 credits | About $100 |
| A year of building and hosting (Product Hunt user) | Not stated in credits | About $2,000 |

Sources: [Lovable credits docs](https://docs.lovable.dev/introduction/credits-and-usage), [Trustpilot](https://www.trustpilot.com/review/lovable.dev), [DEV](https://dev.to/batmanofweb/lovable-pricing-where-the-credits-go-oa7), [Product Hunt](https://www.producthunt.com/products/lovable/reviews). Dollar figures are our arithmetic at $0.25 per credit.

A rule of thumb from these numbers: a simple site or tool fits in Pro 100 with the daily credits; an app with users and a backend under active development usually needs Pro 200 to 400; a team building full-time needs more.

## How has Lovable's pricing changed?

Lovable has reshaped its pricing several times, which is why older guides disagree.

| When | Change | Effect on cost |
| --- | --- | --- |
| Earlier versions | Pricing by messages, then by credits per prompt | Simple, but heavy prompts cost the same as light ones |
| 2025 | Build mode moved to usage-based pricing by complexity | Small edits cheaper, large requests more expensive |
| Mid-2025 onward | Lovable Cloud and AI launched with separate dollar balances | Hosting and AI billed apart from building |
| June to July 2026 | Building, Cloud and AI moved to one credit balance | Hosting now draws from the same credits as building |
| October 5, 2026 | Chat got per-message pricing and a daily chat allowance | Questions and brainstorming metered separately |
| October 15, 2026 | 1-credit connector grant added; student discount narrowed to Pro 100 | Small changes to grants and discounts |

Sources: [Lovable credits docs](https://docs.lovable.dev/introduction/credits-and-usage), [UsagePricing change log](https://usagepricing.com/blueprint/activity/lovable-2026-07-21-packaging), [Lovable subscription plans](https://docs.lovable.dev/introduction/subscription-plans).

Lovable's docs describe the current chat pricing as temporary, applying through October 31, 2026, and the monthly Cloud and AI grants as temporary too. Check the current terms before committing to a large tier.

## Pro or Business: which costs less?

Pro always costs less for the same credits. Business charges twice as much per credit and makes sense only when you need its governance features.

| You need | Pro | Business |
| --- | --- | --- |
| 100 credits a month | $25 | $50 |
| 400 credits a month | $100 | $200 |
| SSO and role-based access | Not included | Included |
| Design templates and personal projects | Not included | Included |
| Workspace publish and Lovable API | Not included | Included |
| Security center and insights | Not included | Included |
| Training data excluded by default | Opt out per account | Yes |
| Priority support | Email only | Included |

If you need Business for one feature, such as SSO, budget for paying double per credit on all your building, and consider whether a smaller Business tier plus Pro workspaces for non-sensitive projects would cost less.

## Which Lovable plan should you pick?

| If you are... | Pick | Why |
| --- | --- | --- |
| Just exploring | Free | 30 build credits a month and free publishing |
| A student or teacher | Pro 100 with education discount | 50% off for up to 12 months |
| Building a site or simple tool | Pro 100 | Code download, custom domain, daily credits, rollover |
| Building an app with a backend | Pro 200 to 400 | Room for development and Cloud usage |
| A small team shipping weekly | Pro 400 or more | Shared pool, usage limits per member |
| A company needing SSO and controls | Business | Governance at twice the per-credit price |
| A large organization | Enterprise | Volume pricing, audit logs, security scans |

## When is Lovable worth the price, and when should you skip it?

|  | Pick instead | Pick Lovable if | Skip Lovable if |
| --- | --- | --- | --- |
| What you build | Superapp, for a native Swift iPhone app | A web app, site or internal tool | You need a native mobile app in the stores |
| How you build | Superapp, which meters by screen rather than by prompt | You prompt in small steps and revert when stuck | You expect to fix bugs by retrying prompts |
| Budget | Base44, which stops at the plan limit | You want rollover and top-ups | Your budget cannot absorb a top-up month |
| Code ownership | Replit, for writing the code yourself | You want code you can download and host elsewhere | You want to edit code by hand most of the time |
| Teams | Pro, unless governance is required | You need SSO on Business | You would pay double per credit for one feature |

## Is Lovable's credit model fair?

Both sides have a case.

The case for: Lovable publishes its prices, per-prompt examples, every tier and every grant. Small edits cost under a credit, Pro users get 5 free credits every day on top of their plan, plan credits roll over for two months, top-ups are available, and you can download your code and leave. Each response shows its cost, long messages check in at 20 credits, and usage limits can cap spending per member or project.

The case against: you cannot know a prompt's cost before it runs, mistakes are charged and non-refundable, prompts get more expensive as your project grows, and since mid-2026 hosting and AI draw from the same pool, so building and running compete for the same credits. Cancelling freezes what you paid for, and Lovable does not publish Cloud or database rates, only per-project estimates.

A fair reading: Lovable is one of the more transparent and flexible credit systems, and the risks are mostly about how you build. Users who keep prompts narrow and revert quickly report sensible spend; users who iterate on large apps or chase bugs report credits vanishing.

## What should you check in Lovable's usage view?

| Signal | What it usually means | What to do |
| --- | --- | --- |
| Single responses costing several credits | Long prompts or large context | Split the request, start focused |
| Many responses on the same bug | A fix loop | Revert and describe the bug once |
| Run credits growing on a quiet project | Backend, jobs or stored files | Pause the backend, delete unused files |
| AI gateway usage climbing | AI features used by your users | Move to your own key via an edge function |
| Run-out estimate before your renewal | You will hit zero mid-cycle | Set a usage limit or plan a top-up |

You can also ask Lovable in the project chat what drives a project's run credit usage; it investigates your jobs, database, storage and AI activity and proposes fixes, charged as normal usage.

## What does Lovable get right on price?

Lovable is the most generous of the major AI builders on several points. Five free build credits every day on Pro and Business, with no monthly cap, is real value for steady small edits; Isa Dahab called the plan "very good value for the price" for exactly that reason. Plan credits roll over, top-ups exist on every paid plan, and published frontends are free to host on lovable.app. Your code is yours: you can sync it to GitHub on any plan and download it on paid plans, and Lovable documents how to host elsewhere, which is not true of every builder.

Many reviewers describe large savings. Johnny Stendahl said Lovable runs his business "for a fraction of what it would cost to hire" someone, and Lisa Denson built products "without spending thousands of dollars." For the right projects, Lovable's price is low.

## Lovable vs Base44 vs Replit: which costs less?

The three popular web builders price the same problem three ways.

|  | Lovable | Base44 | Replit |
| --- | --- | --- | --- |
| Entry paid plan | Pro, $25/mo for 100 credits | Starter, $20/mo ($16 yearly) | Core, $20/mo ($18 yearly) |
| Free daily credits on paid plans | 5 a day | None | Free Mode allowance |
| Hosting | One balance with a 20-credit Cloud grant | Included in every plan | Billed per deployment and database hour |
| When credits run out | Stops; top-ups available | Stops; top-ups rolling out | Overage billed to your card |
| Unused credits | Roll over 2 months; freeze if cancelled | Expire monthly | Core expire; Pro roll over 2 months |
| Code ownership | Download and host elsewhere | Exported code needs Base44's backend | Full code, runs anywhere |
| Mobile | Wrapper workaround | Web view wrapper, both stores | Expo and React Native, App Store |

Sources: [Lovable plans](https://docs.lovable.dev/introduction/subscription-plans), [Base44 pricing](https://base44.com/pricing), [Replit pricing](https://replit.com/pricing). For the full breakdowns, see our [Base44 pricing](https://superapp.dev/blog/base44-pricing) and [Replit pricing](https://superapp.dev/blog/replit-pricing) guides.

## How does Lovable pricing compare to other AI app builders?

Lovable and Superapp both start at $25 a month, but they build different things, and their credits are not comparable units. Compare what each plan produces and how it handles unused credits.

|  | Superapp | Lovable | Base44 |
| --- | --- | --- | --- |
| Entry paid plan | Pro, $25/mo (50 credits) | Pro, $25/mo (100 credits) | Starter, $20/mo ($16 yearly) |
| Next tier | Business, $50/mo (110 credits) | Pro 200 or Business 100, $50/mo | Builder, $50/mo ($40 yearly) |
| What a credit buys | About one screen | 0.5 to 2 credits per typical prompt | Message and integration credits |
| Unused credits | 1x rollover | Roll over 2 months | Expire monthly |
| Top-ups | $18 for 30 credits | $15 for 50 credits on Pro | Rolling out on paid plans |
| What it builds | Native Swift iOS apps plus a website | Full-stack web apps | Hosted web apps |
| App Store | Automated publishing included | Wrapper workaround | Web view wrapper on Builder and up |
| Android | No | Via wrapper | Via web view |

Sources: [Superapp pricing](https://superapp.dev/pricing), [Superapp FAQ](https://superapp.dev/faq), [Lovable plans](https://docs.lovable.dev/introduction/subscription-plans), [Base44 pricing](https://base44.com/pricing).

As a disclosure, Superapp is our product, so weigh this accordingly. If you are pricing Lovable to build an iPhone app, Superapp generates native Swift and a full Xcode project you own, adds subscriptions through RevenueCat and includes automated App Store publishing on its $25 Pro plan, where Lovable needs a wrapper and a separate store process. For web apps, internal tools and sites, Lovable is the more direct tool and gives more credits per dollar on paper, and Superapp does not build Android. For other options, see our [best Lovable alternatives](https://superapp.dev/blog/the-best-lovable-alternatives-in-2026) and [Base44 vs Lovable](https://superapp.dev/blog/base44-vs-lovable-2026-honest-comparison-real-reviews).

## Lovable budget worksheet: set these before your first prompt

| Setting | Where | Suggested starting value |
| --- | --- | --- |
| Plan tier | Plans and credit usage | Pro 100, monthly billing |
| Billing currency | Checkout | Your card's currency, to avoid foreign fees |
| Usage limits | Usage limits and alerts | A monthly cap per member and per project |
| Low-balance alert | Usage limits and alerts | Around 25% of your monthly credits |
| Auto top-up | Plans and credit usage | Off while learning; on with a limit for live apps |
| Credit check-in level | Account settings | Keep the default 20 credits |
| Backend | Project database settings | Pause when not in use; smallest instance that works |
| AI features | Project settings | Your own key via an edge function for heavy use |

## Decide in five questions

1. Are you building a web app, site or internal tool? If yes, Lovable fits; if not, check what you need first.
 2. Will your app need a backend that runs all the time? If yes, budget for Cloud usage beyond the 20-credit grant, or connect your own Supabase.
 3. Do you fix bugs by retrying prompts? If yes, expect fix loops and keep a top-up budget.
 4. Is the main goal an iPhone app in the App Store? If yes, compare a native-Swift builder with flat pricing, such as Superapp.
 5. Do you need SSO or governance? If not, stay on Pro and avoid paying double per credit.

## How to keep your Lovable bill down

1. Start on Pro 100 with monthly billing until your usage settles.
 2. Use your 5 free daily credits for small fixes before touching plan credits.
 3. Think in Plan Mode or Chat mode, and switch to Build mode only to change code.
 4. Keep prompts short and single-purpose; split big features into steps.
 5. Revert to the last working version instead of asking the AI to fix its own fix.
 6. Pause backends you are not using and delete unused files, which cost credits even while paused.
 7. Move heavy AI features to your own provider key through a backend function.
 8. Set usage limits and a low-balance alert, and spend plan credits before you cancel.

## Frequently Asked Questions

**How much does Lovable cost per month?**
Lovable is free with 5 build credits a day up to 30 a month. Pro starts at $25 a month for 100 credits and Business at $50 a month for 100 credits, with tiers up to 10,000 credits. Annual billing gives two months free.

**Is Lovable free?**
Yes. The Free plan includes 5 build credits a day up to 30 a month, a daily chat allowance, small monthly Cloud and AI grants, GitHub sync and free publishing to a lovable.app address. Editing code by hand, downloading code and custom domains need a paid plan.

**What is a Lovable credit worth?**
A Lovable credit costs $0.25 at the Pro entry tier, $0.30 as a Pro top-up and $0.50 on Business. Lovable's examples range from 0.5 credits for a style change to 2 credits for a landing page with images.

**How many credits does a Lovable prompt use?**
Lovable's examples range from 0.50 credits to make a button gray to 2.00 credits for a landing page with images. Plan Mode costs 1 credit per message. Users report long prompts on large projects costing 5 to 10 credits each.

**Do Lovable credits roll over?**
Yes, on Pro and Business while your subscription is active. Monthly plan credits expire 2 months after issue on monthly plans, or 1 month after the annual period ends. Daily credits and monthly grants do not roll over.

**What happens to my Lovable credits if I cancel?**
Unused monthly and rollover credits are frozen when you move to Free and are not refunded. They become usable again if you upgrade before they expire. Top-up and bonus credits remain usable on Free until they expire.

**What happens when I run out of Lovable credits?**
Building stops, AI features in your published app fail and the Cloud backend pauses, with data kept but inaccessible until restarted. Published pages keep serving. Lovable does not bill overage; you top up or upgrade.

**How much do Lovable top-ups cost?**
Top-ups cost $15 for 50 credits on Pro and $30 for 50 credits on Business, in packs from 50 to 10,000 credits. They are valid for 12 months. Free users cannot buy top-ups.

**Does Lovable charge for hosting?**
Publishing a frontend to lovable.app is free. The backend, Lovable Cloud, is billed in credits for database, storage, network, compute and realtime usage after a 20-credit monthly grant. Larger database instances cost more per hour.

**How much does Lovable Cloud cost?**
Lovable does not publish Cloud rates. Each project's Manage instance dialog shows an estimated monthly cost for each database size, based on your last 30 days of usage. Usage beyond the 20-credit monthly grant draws from your general credits.

**Can I avoid Lovable Cloud costs?**
Yes. You can connect your own Supabase project, which Supabase bills directly with its own free tier. Lovable credits still pay for building. You can also pause unused backends and delete unused files to reduce Cloud usage.

**Does Lovable charge for AI features in my app?**
Yes. AI features in your published app bill your credits at provider rates after a 4-credit monthly grant. The built-in connector cannot use your own key, but a backend function with your key lets the provider bill you directly.

**Do you pay for Lovable's mistakes?**
Yes. Build messages are charged on work done whether or not the result works, and Lovable says credits are non-refundable. Reverting costs nothing, so revert and describe the bug once instead of retrying.

**Why are my Lovable credits running out so fast?**
The usual causes are fix loops, long prompts, large projects, Build mode used for questions, and backend or AI usage drawing from the same balance since mid-2026. Check each response's Credits used and the usage details page.

**Can I get a refund from Lovable?**
Lovable says subscription fees and credits are non-refundable except where the law requires. Cancelling does not refund the current period. Users report mixed outcomes on refund requests, so contact support quickly with your workspace name and the charge.

**Is Lovable Pro worth it?**
For most builders, yes. Pro 100 costs $25 a month and adds code editing and download, custom domains, rollover, top-ups and 5 daily credits with no monthly cap. Many reviewers call it good value for small sites and tools.

**What is the difference between Lovable Pro and Business?**
Business adds SSO, role-based access, design templates, workspace publishing, the Lovable API, a security center and priority support, but charges twice as much per credit. Pro is cheaper for the same building.

**Is Lovable annual billing worth it?**
Annual billing gives two months free, for example $250 instead of $300 a year on Pro 100. Credits issued during an annual plan stay valid until a month after it ends. The fee is non-refundable, so confirm your tier first.

**Does Lovable have a student discount?**
Yes. Verified students and teachers get 50% off Pro with 100 credits a month, billed monthly, for up to 12 months. Verification uses an academic email on lovable.dev/students, and the discount can be used once.

**Can Lovable build mobile apps?**
Not natively. Lovable's docs describe wrapping the web app with a web-to-native wrapper and submitting it through Xcode or Android Studio. You also pay Apple's $99 yearly fee and Google's $25 one-time fee.

**Can I export my code from Lovable?**
Yes. You can sync to GitHub on any plan and download the codebase as a zip on paid plans, then host it elsewhere. Database exports exclude stored files, edge function code and secrets.

**Does Lovable charge per user?**
No. Lovable does not charge per seat. Workspace members share the plan's credits, and owners on paid plans can set monthly credit limits per member, project or workspace.

**Do Lovable custom domains cost extra?**
Connecting a domain you own is included on paid plans. Buying a domain through Lovable costs the price shown at checkout, renews automatically, and the renewal price can differ from the purchase price.

**How much does it cost to build an app with Lovable?**
Simple sites and tools often fit in Pro 100 at $25 a month. An app under active development with a backend usually needs Pro 200 to 400, or $50 to $100 a month. One Product Hunt reviewer reported about $2,000 for a year of building and hosting.

**Is Lovable cheaper than Base44?**
Base44's entry plan is cheaper at $16 to $20 a month, and it includes hosting. Lovable gives 5 free daily credits, rollover and downloadable code. Light builders often pay less on Base44, while steady builders may get more value from Lovable.

**Is Lovable cheaper than Replit?**
Replit Core is $20 a month against Lovable Pro at $25, but Replit bills usage beyond your credits automatically, while Lovable stops and asks you to top up. Lovable's bill is more predictable for non-technical builders.

**Is Lovable cheaper than hiring a developer?**
For a first version, usually yes: reviewers describe building products without spending thousands of dollars. For complex apps with heavy iteration, credits and top-ups add up, so compare your monthly spend to a part-time developer once you are past the prototype.

**Does Lovable charge for Plan Mode and chat?**
Yes. Plan Mode costs 1 credit per message plus any research it runs. Chat messages are priced per message, usually a fraction of a credit, after a free daily chat allowance that Lovable describes as temporary.

**Is Lovable secure for apps with user data?**
It can be, but access rules are your responsibility. A 2025 vulnerability, CVE-2025-48757, concerned weak row-level security in generated apps, which Lovable disputes. Business adds a security center; scheduled scans are on Enterprise.

**How do I stop overspending on Lovable?**
Set usage limits and a low-balance alert, keep credit check-ins on, use daily credits first, keep prompts small, revert instead of retrying, pause unused backends, and move heavy AI usage to your own key.

## References

- [Lovable subscription plans](https://docs.lovable.dev/introduction/subscription-plans), plans, tiers, features, student discount
 - [Lovable credits and usage](https://docs.lovable.dev/introduction/credits-and-usage), credit sources, rollover, build examples, Cloud and AI
 - [Lovable credit top-ups](https://docs.lovable.dev/introduction/credit-top-ups)
 - [Lovable out of credits](https://docs.lovable.dev/introduction/out-of-credits)
 - [Lovable manage subscription](https://docs.lovable.dev/introduction/manage-subscription), cancelling and frozen credits
 - [Lovable FAQ](https://docs.lovable.dev/introduction/faq), refunds, code ownership
 - [Lovable database performance](https://docs.lovable.dev/features/database-performance) and [project usage](https://docs.lovable.dev/features/project-usage)
 - [Lovable AI features](https://docs.lovable.dev/features/ai) and [Supabase integration](https://docs.lovable.dev/integrations/supabase)
 - [Lovable custom domains](https://docs.lovable.dev/features/custom-domain) and [mobile store guidance](https://docs.lovable.dev/tips-tricks/mobile-store)
 - [Lovable reviews on Trustpilot](https://www.trustpilot.com/review/lovable.dev), 4.2/5 from 1,894 reviews as of November 3, 2026
 - [Lovable reviews on Product Hunt](https://www.producthunt.com/products/lovable/reviews), 4.7/5 from 212 reviews
 - [Lovable pricing: where the credits go](https://dev.to/batmanofweb/lovable-pricing-where-the-credits-go-oa7), DEV, October 2026
 - [UsagePricing: Lovable packaging changes](https://usagepricing.com/blueprint/activity/lovable-2026-07-21-packaging)
 - [CVE-2025-48757](https://cvemon.intruder.io/cves/CVE-2025-48757)
 - [Superapp pricing](https://superapp.dev/pricing) and [Superapp FAQ](https://superapp.dev/faq)
 - Related: [Lovable Cloud explained](https://superapp.dev/blog/lovable-cloud-explained-costs-supabase-and-what-you-actually-own), [Can Lovable make mobile apps?](https://superapp.dev/blog/can-lovable-make-mobile-apps-how-to-publish-a-lovable-app-to-the-app-store), [best Lovable alternatives](https://superapp.dev/blog/the-best-lovable-alternatives-in-2026), [Base44 pricing](https://superapp.dev/blog/base44-pricing), [Replit pricing](https://superapp.dev/blog/replit-pricing)

 ![Superapp Logo](https://superapp.dev/superapp-logo.svg) Superapp

## Build iOS or web apps with AI

Superapp is AI that builds your iOS or web app and runs your marketing while you sleep.

[Build an app](https://superapp.dev/)

Already have an app? Superapp can get you users with Marketing AI. [Learn more](https://superapp.dev/selfdrive)