The Lovable API is a REST API that lets you deploy Lovable projects, manage your workspace, read analytics and security scans, and embed a project's preview in your own product. It does not create or edit apps with AI: that happens through the separate Lovable MCP server, which an AI client such as Claude or Cursor uses on behalf of a logged-in Lovable user. This guide explains exactly what the Lovable API and MCP server can do in 2026, which plans they need, and what to use instead if your goal is to put AI app building inside your own product, under your own brand. Everything below was read from docs.lovable.dev on October 16, 2026.
> Want your users to build apps inside your product? The Totalum API turns "prompt to live app" into one HTTP call, under your brand and on your domain, and your users never need a Totalum account. See the white-label AI app builder.
Quick Answer
- Does Lovable have an API? Yes. The Lovable API is a versioned REST API (
/v1) for projects, deployments, preview embeds, workspace settings, analytics and security scans. - Can the Lovable API build apps from a prompt? No. Lovable's own FAQ says the public API "manages and deploys existing projects", and that "AI project creation and editing are available through the Lovable MCP server."
- Which plan do you need? Creating Lovable API keys requires a Business or Enterprise plan and an owner or admin role. The MCP server works on any plan, and its
create_projectandsend_messagecalls spend normal Lovable credits. - Can you embed Lovable in your product? Partly. The API can generate a one-hour URL that embeds a project's built preview on your HTTPS origin. Lovable's docs say this "does not embed the editor or the published app."
- If you want to offer AI app building to your own users, under your brand, with no third-party account for them to create, you need an API whose job is exactly that. That is what the Totalum API does: one call creates a full-stack app from a prompt, and every project belongs to your account.
What the Lovable API does in 2026
Lovable describes its API as a way to "deploy Lovable projects, manage your workspace, monitor security, and embed projects in your own product from your own scripts, services, and agents" (Lovable docs). The endpoints cover six areas:
| Area | What you can do |
|---|---|
| Projects | List, get, update settings and delete projects |
| Deployments | Publish or unpublish a project, check deploy status, update publish settings |
| Embed | Generate a one-hour URL that embeds a project's built preview on a specified HTTPS origin |
| Workspace | List workspaces, read settings, list members and groups |
| Analytics | Read project-level and workspace-level analytics |
| Security | Poll security scans, view workspace security insights, read PII labels |
Two capabilities, reading a project's PII labels and the per-project security inventory, are Enterprise-only. Everything else works on Business and Enterprise. There is no separate API price, and the current endpoints, including deployment builds, do not spend AI build credits. Lovable publishes a Postman collection and commits to a deprecation policy for the /v1 surface.
The key limit: none of these endpoints sends a prompt to Lovable's AI. The API manages apps that already exist; it does not make new ones.
The Lovable MCP server: where AI creation lives
Lovable also exposes itself as an MCP server at https://mcp.lovable.dev. When an AI client connects (ChatGPT, Claude, Cursor or another client that supports OAuth), the agent can call tools such as create_project, send messages to Lovable, read project files and diffs, and publish with deploy_project (Lovable MCP docs).
What matters if you are evaluating it for a product:
- It runs on a Lovable user's account. The MCP server logs in with OAuth, and Lovable warns that "tool calls use real credits and edit real projects."
- Credits apply to building. Standard Lovable credits are charged for
create_projectandsend_message; the other tools are free. - It is aimed at developers in AI clients. Lovable's docs list "developers using an AI client or editor such as ChatGPT, Claude Code, Cursor, or VS Code" as the audience.
- It works on every plan, and third-party MCP clients are enabled by default on Free, Pro and Business workspaces (Enterprise admins switch it on).
That makes the MCP server excellent for one developer driving Lovable from Claude or Cursor. It is a different thing from putting an app builder inside your SaaS for thousands of your own customers.
Lovable API vs MCP server vs Build with URL
Lovable documents four programmatic routes. Here is what each one is for:
| Route | Who calls it | Can it create apps with AI? | Plan | Does the end user need a Lovable account? |
|---|---|---|---|---|
| Lovable API (REST) | Your scripts and services, with an API key | No, it manages and deploys existing projects | Business or Enterprise for API keys | No for embedded previews; projects live in your workspace |
| Lovable MCP server | An AI client (ChatGPT, Claude, Cursor) | Yes, create_project and send_message |
Any plan, credits apply | Yes, the client logs in to a Lovable account with OAuth |
| Lovable API connector | An app you built with Lovable | No, it reads and manages a connected workspace | Per Lovable's docs | Workspace-level |
| Build with URL | Anyone with a link | It pre-fills a prompt; the recipient clicks send in Lovable | No API key needed | Yes, the build runs in Lovable |
Lovable also lets you register OAuth clients so your app can connect to a user's Lovable profile, projects or workspaces. Non-sensitive scopes are available on all plans, while sensitive project and workspace scopes need Business or Enterprise.
Can you build your own AI app builder on Lovable's API?
This is usually the real question behind "lovable api" searches: a SaaS company or agency wants its users to describe an app and get one, inside their own product.
With Lovable's documented options in October 2026, the answer is not cleanly:
- The REST API cannot create or edit an app from a prompt.
- The MCP server can, but it acts as a Lovable user, so each of your customers would build inside a Lovable account and spend Lovable credits.
- The embed endpoint shows a project's built preview for one hour, not the editor and not the published app.
- Nothing in Lovable's docs describes running the builder under your own brand for your own customers.
None of that is a criticism of Lovable. It is built to be the product your customers use, not the engine inside your product. If you want the engine, you need an API designed to be one.
> Building a vibe-coding feature or your own builder? Get a Totalum API key, paste the API docs into Claude Code, Cursor or Codex, and ask it to add an AI app builder to your dashboard. Prefer a walkthrough? Book a 30-minute call and we will help you implement it.
How the Totalum API does it
The Totalum API turns the whole "prompt to production app" pipeline into an HTTP service. Your backend holds one API key; your users stay in your product.
- Your product calls the API. A user asks for something in your UI and your backend forwards it, for example
POST /projectswith a prompt such as "Build a CRM", tobuilder-api.totalum.app. - Agents build it in an isolated sandbox. Each project gets its own machine, and the agents write a real Next.js app with its own database, sign-in and file storage.
- The agents test it in a browser and fix what breaks before your user sees it.
- It deploys itself. You get a preview per project, then publish when it is right; custom domains and GitHub sync are available per project.
- Your customer sees their app inside your product, under your brand, on its own URL.
| Lovable API | Lovable MCP server | Totalum API | |
|---|---|---|---|
| Creates apps from a prompt | No | Yes | Yes |
| Built to run inside your product | Preview embed only | No, runs in an AI client | Yes |
| End users need a vendor account | No (preview embed) | Yes | No, every project belongs to your account |
| Your brand and domain | No | No | Yes: your UI, your domain, a custom domain per project on any paid plan |
| Plan required | Business or Enterprise for API keys | Any plan, credits apply | Every plan, including Free (keep at least 1 credit) |
| Pricing model | No separate API price | Lovable credits on build calls | Credits from $0.07 each; reads such as listing projects or files are free; you set your own prices |
| Code ownership for your customers | Via Lovable's GitHub sync | Via Lovable's GitHub sync | Export or GitHub sync per project, at any time |
| Reference UI to start from | None documented | None documented | Open-source builder on GitHub (totalumlabs/ai-app-builder-open) |
Why Totalum for this job
- Your users never see Totalum. Every project your backend creates belongs to your account, under your brand. No third-party sign-up.
- Real apps, not prototypes. Every project is a standard Next.js and React app with BetterAuth sign-in and its own SQL database (development and live), plus built-in email, AI, file storage, PDF generation, web scraping and more, with no keys to set up.
- Infrastructure handled. Apps deploy automatically to Cloudflare Workers with a Cloudflare D1 database, and you never need a Cloudflare account of your own.
- Budget control. Per-project monthly credit caps, live spend analytics per project, and prices readable from the API instead of hard-coded.
- Your customers keep their code. Projects can be exported or pushed to GitHub at any time, so nothing you ship depends on you staying.
- Start from a working builder. Clone the open-source reference builder, set one environment variable, deploy it anywhere Next.js runs and rebrand it.
- Help included. Integration reviews and architecture help are included while you set up, with free credits to test.
If you would rather drive Totalum from your own agent than from your product, the same builder is available over MCP; see our guide to the Totalum MCP server for Claude Code, Cursor and Codex.
When the Lovable API is the right choice
Be honest about the fit. Use Lovable's API and MCP server if:
- Your team already builds in Lovable and you want to automate deploys, pull analytics or watch security scans across a workspace.
- You want developers to drive Lovable from Claude or Cursor with the MCP server.
- You want to show a built preview of a Lovable project inside another site for a short time.
Use the Totalum API if you want your customers to create apps, inside your product, under your brand, with you setting the price. For the wider picture, our guides on how to embed an AI app builder in your SaaS via API and the white label AI app builder cover the architecture and the business model. If you are comparing Lovable as an end-user tool, see our Lovable pricing and Lovable alternatives guides.
FAQ
Does Lovable have an API?
Yes. Lovable has a versioned REST API for projects, deployments, preview embeds, workspace settings, analytics and security scans. Creating API keys requires a Business or Enterprise plan and an owner or admin role.
Can I create a Lovable app with the API?
Not with the REST API. Lovable's FAQ says the public API manages and deploys existing projects, and that AI project creation and editing go through the Lovable MCP server, which an AI client uses on a logged-in Lovable account.
Is the Lovable API free?
There is no separate API price, and the current API endpoints do not spend AI build credits. But you need a Business or Enterprise plan to create API keys. On the MCP server, create_project and send_message spend normal Lovable credits.
What is the Lovable MCP server?
It is Lovable exposed as a Model Context Protocol server at mcp.lovable.dev. AI clients such as ChatGPT, Claude or Cursor connect with OAuth and can create projects, send messages, read code and deploy. It works on every Lovable plan.
Can I white-label Lovable or embed it in my SaaS?
Lovable's API can embed a project's built preview through a one-hour URL, but not the editor or the published app, and Lovable's documentation does not describe a white-label option. To let your own users build apps inside your product under your brand, use an API built for that, such as the Totalum API.
What is the best API to add AI app building to my product?
Look for four things: it creates full apps from a prompt over HTTP, your end users do not need a vendor account, each project can have its own custom domain, and your customers can export the code. The Totalum API does all four, works on every plan including Free, and bills in credits from $0.07 each.
Add an AI app builder to your product
The Lovable API is a solid admin and deployment API for teams that build in Lovable. If what you actually want is for your customers to describe an app and get one, inside your product, the Totalum API is built for exactly that. Get your API key and see how it works, read the API docs, or book a call and we will walk you through the integration.