Lovable pricing

About

Lovable is an AI full-stack app builder: you describe an app in natural language and it generates a working React + Supabase application — auth, database, hosting and connectors included — that you can export to GitHub and own outright. It positions itself less as a coding copilot for engineers (its FAQ explicitly contrasts itself with Cursor) and more as a “vibe coding” tool that lets entire teams — PMs, designers, marketers, operators — build real software while engineers keep control via standard code and GitHub PRs.

Commercially, Lovable runs a freemium subscription metered by credits. As of mid-2026 a single credit balance covers all three things a customer can consume: build usage (messages sent to the agent), Cloud usage (hosting plus the built-in database, storage, network, compute and realtime backend) and AI gateway usage (model calls made by the app you deployed). Every plan layers refilling free grants — daily build credits plus a monthly Cloud grant and a monthly AI grant — on top of the general credits included with the plan. Notably, paid plans are not per-seat: a workspace’s credits are shared across unlimited users, so customers pay for AI capacity rather than headcount. The ladder runs Free ($0) → Pro ($25/mo) → Business ($50/mo) → Enterprise (platform fee, volume based pricing), with student and K12-classroom programs on the side.

For the most current information on Lovable’s pricing and market position, visit Lovable.

Pricing summary : How Lovable’s pricing model works

Lovable’s bill is built from two dimensions: a flat monthly subscription tier and credit consumption. Since the mid-2026 rollout of a unified balance, one credit currency pays for three kinds of usage — building the app, hosting it on Lovable Cloud, and the AI-gateway calls a deployed app makes — so there is no longer a separate dollar balance for Cloud and AI. The subscription sets the included credit allotment and the feature gate; usage above it is handled by on-demand credit top-ups priced per plan, while unused monthly plan credits roll over each billing cycle. Unusually for the category, the subscription is not priced per seat — a workspace’s credits are shared across unlimited users, so adding teammates doesn’t add cost; running out of credits does.

• Free — $0/mo, no credit card needed. Free grants only: 5 daily build credits (up to 30 per month), a 20-credit monthly Cloud grant and a 4-credit monthly AI grant. Community support.
• Pro — from $25/mo, or $21/mo billed annually (Save $50), for 100 monthly credits. The credits-per-month selector on the card is a price ladder, not a free choice: 200 credits is $50/mo and the ladder runs to 10,000 credits at $2,250/mo. Adds 5 daily build credits and the same 20-credit Cloud / 4-credit AI monthly grants, credit rollovers, on-demand top-ups at $15 per 50 credits ($0.30/credit), per-member credit limits, email support.
• Business — from $50/mo, or $42/mo billed annually (Save $100), for the same 100 monthly credits and grants as Pro, plus SSO, team workspace, role-based access, security center and priority support. Its ladder runs at roughly 2× Pro’s (200 credits is $100/mo, up to 10,000 at $4,300/mo). Top-ups cost $30 per 50 credits ($0.60/credit).
• Enterprise — “Platform fee” with volume based pricing and unlimited users; adds volume-based credit pricing, commitment credits, SCIM, audit logs, publishing/sharing controls, dedicated support and onboarding services. Book a demo.
• Student / classroom — verified students get up to 50% off Pro: one year of Lovable Pro for $12.50/month. Per Lovable’s student FAQ that is “50% off on the Lovable Pro 100 credits monthly plan, or a discount of $12.50/month on all other plans”, valid “for up to 12 months” and “only valid for users on the free plan”. K12 grades 6-12 get free classroom access via the imagi Edu partnership; universities go through Lovable for campus (contact sales).

What makes this different: the seat decoupling plus a single meter. Credits — not users — are the value metric, so the same $25 or $50 plan covers a solo builder or a whole team, and the same credit-based billing unit now spans agent messages, hosting and inference in one hybrid pricing model.

Pricing by product

Lovable (subscription plans)

Monthly credit tiers (the credits-per-month selector)

Pro and Business are not single prices. Each plan card carries a credits-per-month dropdown that defaults to the cheapest rung — 100 credits — and every step up the ladder raises the subscription price. Annual billing bills the year up front at a discounted per-month rate:

Business is exactly 2× Pro on every rung up to 5,000 credits and a shade under 2× on the top two. Both ladders discount modestly with volume: Lovable’s stated plan credit rate is $0.25 per credit on Pro and $0.50 per credit on Business, and the largest rungs land just below that. Upgrading mid-cycle grants only the difference — “upgrading from 100 credits to 200 credits adds 100 credits, not 200”.

Credits: what they cover, what they cost

One credit balance pays for build usage (messages to the agent), Cloud usage (hosting plus the built-in database, storage, network, compute and realtime backend) and AI gateway usage (model calls from your deployed app). Usage-specific grants are spent before general credits, and grants do not roll over.

Per Lovable’s docs, “Monthly Cloud and AI grants are a temporary offering and subject to change.” The grants are a Free/Pro/Business entitlement only — “Enterprise plans do not include free daily build credits or the monthly Cloud and AI grant.”

Build-mode credit costs are complexity-weighted; Plan mode is flat. Lovable’s own illustrative examples:

Top-ups are Pro/Business only, billed as one-time Stripe payments, and valid for 12 months from the most recent purchase. Monthly plan credits expire 2 months from issue on monthly plans, or 1 month after the annual billing period ends on annual plans.

The 2× top-up gap tracks the subscription itself rather than a penalty: Lovable’s docs put the plan credit rate at $0.25 per credit on Pro and $0.50 per credit on Business (so a $10 Cloud/AI balance converted to 40 credits on Pro and 20 on Business during the July 2026 migration). Per Lovable, that “does not mean Cloud or AI gateway usage is cheaper on Business… fewer credits are deducted because each Business credit represents more dollars.”

Education programs

Sales motions across products: PLG / self-serve for Free, Pro and Business (sign up and pay online); sales-led for Enterprise (book a demo, custom platform fee) and Lovable for campus.

Hidden costs : What Lovable users actually pay

The sticker price ($25 or $50/mo) is the floor, not the bill. Lovable meters work in credits, and since July 2025 a credit is no longer a flat “one message” — it is complexity-weighted. A simple chat reply is ~1 credit, a minor UI tweak ~0.5, and a complex build step (“add authentication with sign-up and login”) can cost 1.5+ credits. A from-scratch app skeleton commonly burns ~2 credits before you have changed anything. That makes the 100 monthly credits on Pro/Business easy to exhaust during active iteration — and vague prompts burn faster because they force more rounds.

When the pool runs out, the lever is on-demand top-ups, which are priced differently by tier: Pro pays $15 per 50 credits ($0.30/credit), Business $30 per 50 credits ($0.60/credit), with purchased credits expiring 12 months after the most recent purchase. The second, quieter driver is that the same credit balance also pays for Lovable Cloud (hosting, database, storage, network, compute, realtime) and for AI-gateway calls your deployed app makes. Each plan only includes a 20-credit monthly Cloud grant and a 4-credit monthly AI grant, so once an app has real traffic, running it competes with building it for the same 100 monthly credits.

The combination of a flat subscription, a variable complexity-weighted credit meter, and running costs that draw from the very same balance is exactly what reviewers flag as making month-to-month spend hard to forecast. Credit rollovers on paid plans soften this for bursty teams, but the burn rate is set by prompt quality and app complexity, not headcount.

Want to estimate your own Lovable bill? Use the Lovable pricing calculator to model credit burn and top-ups against your usage patterns.

Pricing evolution : Lovable pricing history and changes

Cadence

Tracked range: 2024 Q4–present. Dated changes are corroborated by Lovable’s blog, docs and secondary coverage.

Notable changes

• 2024-11-21 — Lovable introduces subscription tiers (Free / Starter $20 / Launch $50 / Scale $200) priced by successful edits/messages per day or month, with early-access users grandfathered (Lovable blog).
• 2025-07-24 — Pricing shifts from flat “1 credit = 1 message” to complexity-weighted credit consumption (chat ~1, tweaks ~0.5, complex builds 1.5+; error-fix retries generally free) as Lovable goes agentic and crosses $100M ARR — billed as the fastest software company ever to that mark (Tech.eu, Sacra).
• 2025–2026 — Tier names converge on the current Free / Pro $25 / Business $50 / Enterprise ladder, with the defining move being flat per-workspace pricing shared across unlimited users rather than per-seat licensing.
• 2026-06-30 — No price moves, but the pricing page reframes the offer: each paid card now leads with 100 monthly credits instead of the daily-credit cap, and Pro’s lovable.app domain allowance goes unlimited. A presentation change that quietly shifts the buying decision from “how often can I prompt” to “how much capacity do I need” (Lovable pricing page).
• 2026-07-21 — Lovable merges the separate Cloud and AI dollar balances into the single credit balance: remaining dollar balances were converted to credits at the plan’s credit rate, and the monthly Cloud and AI allowances are reissued as credit grants (20 Cloud + 4 AI per month on Free, Pro and Business) on top of 5 daily build credits. Headline prices ($0 / $25 / $50 / platform fee) and top-up rates ($0.30 and $0.60 per credit) do not move (Lovable docs).

The unified credit balance in detail

This is a billing-unit migration rather than a price rise, and it is worth reading carefully because the sticker price hides the change entirely.

• What actually moved. Before, a workspace held credits for agent messages plus a dollar-denominated balance for Lovable Cloud (hosting, database, storage, network, compute, realtime) and for the AI gateway a deployed app calls. Those dollar balances were converted into credits at the plan’s credit rate and folded into one pool. Lovable states the underlying cost of running projects is unchanged.
• Grants replaced dollars, but grants are weaker money. The monthly Cloud and AI allowances now arrive as usage-specific credit grants (20 and 4). They are spent before general credits, they do not roll over, and Lovable’s docs call them “a temporary offering and subject to change” — so the softest part of the new package is also the part most easily withdrawn.
• Build and run now compete for the same pool. Once the 20 + 4 grants are gone, hosting and inference for a live app draw from the same 100 monthly credits used to build it. Heavy iteration and production traffic are now rivals for one budget, which is why Lovable’s own docs recommend raising the auto-top-up threshold to 50–100 credits for busier apps.
• The failure mode got sharper. An empty balance no longer just stops you building — deployed apps that depend on Cloud or AI features can pause. Availability is now coupled to a credit meter, which raises the stakes on the low-balance alerts and auto-top-up guardrails in the billing UI.
• Rollout is gradual and history is truncated. Some workspaces still saw the old two-balance experience during the transition, and Run-usage history only begins on the date a workspace switched over — June 1, 2026 at the earliest — so year-over-year running-cost comparisons are not available yet.

What’s unique : Lovable’s distinctive pricing mechanics

1. Seats are decoupled from price — you buy AI capacity, not headcount. The single most distinctive choice is that Pro ($25) and Business ($50) are per-workspace, not per-user: a workspace’s 100 monthly credits are shared across unlimited collaborators. In a category where Cursor, GitHub Copilot and most dev tools charge per seat, Lovable charges for the thing it actually spends money on — model inference — and lets the whole team (PMs, designers, marketers) onto the same plan for free. The value metric is the credit, not the login.

2. Complexity-weighted credits, not flat per-message billing. Since July 2025 a credit is a unit of work, not a unit of interaction: a one-line tweak can cost ~0.5 credits, a heavy build step 1.5+, and failed-build “try to fix” retries are generally free. This aligns spend with the model cost of the request and softens the bad-UX failure mode of charging users for the AI’s own mistakes — a deliberate contrast to flat-message competitors.

3. A daily-credit floor plus monthly pool, rollovers and tier-priced top-ups. Every plan layers a refilling daily build allowance (5/day) on top of the monthly pool, so even Free users get a steady trickle (capped at 30/month) while paid users keep the daily build credits with no monthly cap. Unused monthly credits roll over, and overflow is handled by on-demand top-ups priced by tier (~$0.30/credit on Pro, ~$0.60/credit on Business) rather than a forced upgrade — a continuous-meter design wrapped around a subscription shell.

4. One currency for building and running the software you built. Since 2026-07-21 the credit is not just the agent’s meter: the same balance pays for Lovable Cloud hosting and for the AI-gateway calls a deployed app makes, after Lovable converted the old dollar-denominated Cloud and AI balances into credits. Most tools in this category bill the build tool as SaaS and the runtime as cloud infrastructure on a separate invoice; Lovable collapsed both into one number a non-developer can read. The design cost is that dev-time and production usage now share a single budget, with only a 20-credit Cloud grant and 4-credit AI grant ring-fenced per month — and Lovable’s docs flag those grants as temporary.

5. Usage-specific grants that expire before the money you paid for. The spend order is deliberate: daily build, Cloud and AI grants are consumed first, then general credits closest to expiry. Grants never roll over, while purchased and monthly credits do. It is a quietly sophisticated ledger — free capacity is spent while it is still free, and the buyer’s paid balance is preserved — but it means the headline “100 credits” understates neither capacity nor risk cleanly, since the free layer resets on three different clocks.

Strengths & weaknesses

Billing UX : Lovable billing controls and transparency

• Monthly / Yearly toggle — one page-level switch flips all cards between monthly and annual billing, labelled “2 months free”, showing the discounted per-month rate ($21 Pro, $42 Business) with explicit “Save $50” / “Save $100” badges on the cards.
• Monthly-credit selector — Pro and Business cards each carry a dropdown that defaults to “100 monthly credits”, so buyers pick their capacity on the pricing page rather than only their tier. The dropdown changes the price as well as the allowance — it is an 11-rung ladder from 100 credits ($25/mo on Pro) to 10,000 ($2,250/mo) — and it lists paid rungs only, so it can’t be used to drop back to Free.
• Plans & credit usage (Settings) — the single billing hub: credit balance, usage tracking, plan changes, invoices, “Manage → Downgrade to free” for cancellation.
• Credit bar + Credit balance dialog — a persistent bar in the dashboard and project editor shows remaining daily build credits, monthly credits, personal, team or commitment credits; the Breakdown tab (Pro/Business) lists each grant’s type, expiry and remaining amount, and the History tab (Pro/Business/Enterprise) shows up to 12 months of credit events.
• Usage details with filters — daily consumption charts filterable by credit type (All / Build / Run), project, person and group (Business and Enterprise), over 30/90-day or custom ranges, plus Projects and People tabs. You can also ask Lovable in chat: “How many credits did this workspace use this month?”
• Per-response cost disclosure — the three-dot menu under any agent response shows that message’s exact credit cost; stopped Build-mode requests are charged only for work completed.
• Auto top-up with guardrails — set a top-up amount (default 100 credits; 50–1,000 options), a trigger threshold (default 25 credits; 25/50/100) and a monthly spend limit (default 400 credits, up to No limit). Auto top-up is paused automatically when you upgrade Pro → Business because the price per credit changes.
• One-time top-ups — buy 50 to 10,000 credits on demand without changing tiers; the UI shows cost before purchase and credits land instantly.
• Per-member credit limits — a Pro-and-up control that caps how many credits an individual workspace member can spend out of the shared pool.
• Low-balance alerts and blocking dialogs — chat nudges, in-app banners and owner/admin emails fire on low credits, expiring credits, failed auto top-ups and spend-limit hits; when the balance hits zero, building stops and deployed apps relying on Cloud or AI features can pause.
• Shared-workspace billing — credits are pooled across unlimited users, so adding collaborators is a no-cost action; the billing surface tracks capacity, not seats.
• Self-serve student verification — students unlock the 50%-off Pro rate by verifying an educational email or student ID directly, no sales contact. The discount is scoped: existing paid customers are excluded (“only valid for users on the free plan”), it runs up to 12 months, and cancelling the subscription forfeits it with no reactivation.
• Annual-billing switch in-app — Pro and Business can move from monthly to annual from Settings → Plans & credit usage; the plan card updates to the discounted per-month rate ($21 Pro, $42 Business) and, per Lovable’s docs, annual billing also raises the rollover limit for unused credits.
• Enterprise governance controls — SSO/SAML, SCIM provisioning, role-based access, audit logs and publishing/sharing controls gate the Business and Enterprise billing tiers; on Enterprise workspaces usage details are visible to admins and owners only.

Strategic wins : Why Lovable’s pricing decisions worked

1. Picking credits over seats unlocked viral team adoption

By making the value metric a credit and the plan per-workspace, Lovable let entire teams pile onto one $25 plan for free. That removed the classic per-seat tax that slows bottoms-up adoption inside companies, and it matched the cost driver (model inference) to the price. Combined with the open-source GPT Engineer halo, it is a textbook case of the shift away from per-user licenses — and it helped Lovable reach a reported $100M ARR roughly eight months after launch, billed as the fastest software company ever to that mark.

2. Complexity-weighting the credit aligned price with cost without bill-shocking on failures

The July 2025 move from flat per-message to complexity-weighted credits — while keeping error-fix retries free — tightened the link between what a request costs Lovable and what the user pays, without punishing people for the AI’s own mistakes. It’s a pragmatic middle ground between flat subscriptions and pure metering, and a useful data point for anyone weighing outcome- and usage-based pricing for AI products.

3. The free daily-credit trickle keeps the funnel full

A no-card Free tier with 5 refilling daily credits gives curious non-developers enough rope to ship something small and feel the magic, then hit a natural ceiling that nudges them to Pro. Choosing a metric that’s both the demo currency and the billing currency is a clean example of picking the right usage metric: the same credit that sells the product is the one that monetizes it.

4. Collapsing three meters into one currency removed the product’s worst comprehension tax

The 2026-07-21 migration ended the awkward state where a customer held credits for building and a dollar balance for running — two units, two mental models, two places to run dry. Converting the Cloud and AI balances into credits at the plan rate, and reissuing their allowances as credit grants, means a non-developer now watches exactly one number. Doing it at unchanged headline prices and unchanged top-up rates is what made it readable as a simplification rather than a repricing, and it is the right instinct for anyone weighing how many usage metrics one product should meter.

Areas to improve : Gaps in Lovable’s pricing approach

1. Credit burn is genuinely hard to predict

The most consistent reviewer complaint is forecasting: complexity-weighted credits mean an identical-looking task can cost 0.5 or 1.5+ credits, and vague prompts multiply the rounds. The 2026-07-21 merge makes this harder, not easier — the same 100 monthly credits now absorb hosting and AI-gateway usage from every deployed app as well. Better in-product burn estimates and a clearer “credits remaining at this rate” signal, split by build versus run, would directly reduce the cost-unpredictability bill shock the model invites.

2. Merging the meters fixed the visibility problem and created a contention problem

The old complaint — that Cloud usage billed on a separate dollar ledger the pricing page never showed — is genuinely resolved as of 2026-07-21. What replaced it is budget contention: past the 20-credit Cloud and 4-credit AI grants, keeping production alive competes with shipping features for one pool, and an empty balance can pause deployed apps. The fix is a floor, not more dashboards — a ring-fenced runtime reserve (or a separate spend limit for Run usage) so an intense build week cannot take a live app offline. Publishing an expected credits-per-1,000-requests figure would let buyers size that reserve at all.

3. A “temporary” grant is doing load-bearing work in the pricing story

The 20 Cloud and 4 AI monthly credits are what make the merged balance feel free at small scale, yet Lovable’s own docs label them “a temporary offering and subject to change,” and they don’t roll over. That is a real repricing lever sitting behind a footnote: withdrawing the grants would raise effective cost for every hosted app without touching a headline number. Committing to a notice period, or converting the grants into a stated plan inclusion, would cost Lovable little today and buy a lot of trust with the enterprise buyers it is now hiring to serve.

4. Opaque Enterprise and an inverted top-up curve

Enterprise is quoted as a “platform fee based on company size” with no public anchor, which makes it hard for mid-market buyers to self-qualify — even though the plan now documents commitment credits as a named balance type. And top-ups cost roughly 2× more per credit on Business ($30/50) than on Pro ($15/50) — counterintuitive for the higher-priced tier — which deserves either a published rationale or a flatter curve.

Key takeaways

1. Pay for capacity, not seats. Pro ($25) and Business ($50) are per-workspace with credits shared across unlimited users — adding teammates is free, running out of credits is what costs money.
2. A credit is a unit of work, not a message. Since July 2025 credits are complexity-weighted (chat ~1, tweaks ~0.5, complex builds 1.5+), and failed-build error fixes are generally free.
3. The sticker price is a floor, and since 2026-07-21 it covers more work. 100 monthly credits go fast under iteration, and the same pool now also pays for hosting and AI-gateway calls once the 20-credit Cloud and 4-credit AI grants are spent; expect tier-priced top-ups (~$15/50 on Pro, ~$30/50 on Business).
4. Free is a real funnel, not a trial. Every plan including Free gets refilling daily credits (5/day), giving non-developers enough to ship something before hitting a natural upgrade ceiling.
5. Growth followed the metric. Choosing credits-over-seats helped Lovable reach a reported $100M ARR in ~8 months — a marquee proof point for usage-aligned pricing in AI dev tools.

UBP implications

1. Decoupling seats from price can be a growth weapon, not just a billing detail. When your real cost is model inference, per-seat pricing taxes the wrong thing. Lovable’s per-workspace prepaid-credit pool let whole teams adopt for free and made the credit the single metric that both demos and monetizes the product.
2. Complexity-weighted metering is the honest middle path — but it shifts the forecasting burden to the buyer. Charging more for harder work (and nothing for the AI’s own retries) aligns price with cost, yet it makes spend non-linear. If you adopt it, invest equally in burn-rate visibility, or you import the bill-shock problem you were trying to avoid.
3. Unifying billing units is a real pricing move even when no price changes. Lovable’s 2026-07-21 merge of its Cloud and AI dollar balances into credits shipped with every headline number untouched — yet it changed what a credit means, which budget production usage draws on, and what happens when a workspace hits zero. If you consolidate meters, say plainly what now competes for the same pool, and give the customer a way to protect the workload that must not stop.

Sources

• Lovable pricing page (accessed 2026-07-21)
• Lovable credits and usage (docs) (accessed 2026-07-21)
• Lovable subscription plans and credit tiers (docs) (accessed 2026-07-21)
• Lovable for enterprises (accessed 2026-07-21)
• Lovable for students (accessed 2026-07-21)
• Lovable for the next generation (classroom / imagi Edu) (accessed 2026-07-21)
• Lovable blog: targeted edits & pricing updates (accessed 2026-06-08)
• Lovable changelog (accessed 2026-06-08)

Bottom line

Lovable’s pricing is the clearest production-scale bet on credits-over-seats in AI dev tools: one flat $25 or $50 workspace plan, shared across an entire team, metered by complexity-weighted credits rather than logins. That choice — pay for AI capacity, not headcount — helped it reach a reported $100M ARR in roughly eight months. The July 2026 merge of Cloud and AI dollar balances into that same credit pool doubles down: one currency now buys the building, the hosting and the inference, at unchanged headline prices. The catch is forecasting, and it got sharper rather than softer — a non-linear credit meter, tier-priced top-ups, and a live app that competes with your build week for the same 100 credits mean month-to-month spend is genuinely hard to predict, which is exactly the trade-off usage-aligned pricing demands you manage in the open.

Want to estimate your own bill? Try the Lovable pricing calculator, or compare Lovable against other developer-tools companies in the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

One credit balance for build, Cloud and AI usage

Jul 2026

Lovable folded its separate Cloud and AI dollar balances into the single credit balance: remaining dollar balances were converted to credits at the plan's credit rate, and monthly Cloud and AI grants are now issued as credits (20 Cloud credits and 4 AI credits per month on Free, Pro and Business) rather than dollars. Lovable states running costs are unchanged, and that the grants are 'a temporary offering and subject to change'. Dollar-based Cloud/AI top-ups and auto top-up were replaced by credit-based controls in Settings → Plans & credit usage. Headline prices are unchanged: Free $0; Pro $25/mo ($21 annual, Save $50); Business $50/mo ($42 annual, Save $100); Enterprise platform fee with volume based pricing. Top-ups stay at $15 per 50 credits ($0.30/credit) on Pro and $30 per 50 credits ($0.60/credit) on Business.

Current pricing captured (credit display simplified)

Jun 2026

Headline prices unchanged — Free $0; Pro $25/mo ($21 annual, save $50); Business $50/mo ($42 annual, save $100); Enterprise custom platform fee by company size; students up to 50% off Pro (~$12.50/mo). The pricing page now leads with each paid tier's 100 monthly credits and drops the explicit daily-credit-cap wording; per docs, paid plans keep 5 daily build credits with no monthly cap (Free is capped at 30/mo). Pro now lists unlimited lovable.app domains. Top-ups documented at $0.30/credit (Pro) and $0.60/credit (Business).

Pricing captured (daily + monthly credit framing)

Jun 2026

Free $0 (5 daily credits, up to 30/mo); Pro $25/mo ($21 annual); Business $50/mo ($42 annual); both paid tiers 100 monthly credits + daily credits, shared across unlimited users. Enterprise custom platform fee by company size. Students up to 50% off Pro (~$12.50/mo).

Shift to granular credit consumption + agentic mode

Jul 2025

Lovable moved from 1 credit = 1 message to complexity-weighted credit consumption (simple chat ~1 credit, minor tweaks ~0.5, complex builds 1.5+; failed-build error fixes generally free) alongside its agentic relaunch. This coincided with crossing $100M ARR ~8 months after launch. Sources: https://lovable.dev/blog/agent ; https://sacra.com/c/lovable/

Lovable launches paid tiers (from GPT Engineer)

Nov 2024

GPT Engineer relaunched as the Lovable web app and introduced subscription tiers: Free ($0, 5 messages/day), Starter ($20/mo), Launch ($50/mo) and Scale ($200/mo), metered by successful edits/messages per day or month. Early-access users grandfathered. Source: https://lovable.dev/blog/2025-01-13-targeted-edits-supabase-integration-improvements-and-pricing-updates