Lovable MCP Server: Build From Claude, Cursor, or Codex (2026)

One-sentence definition

The Lovable MCP server is a remote Model Context Protocol endpoint at https://mcp.lovable.dev that gives any MCP client OAuth-authenticated access to your Lovable workspace — create_project, send_message, get_diff, query_database, deploy_project, and forty-plus more tools — over Streamable HTTP, billed against your normal Lovable credit balance and gated to Pro and Business plans.

That sentence is the whole launch. Everything below unpacks one of its words.

Why Lovable shipped this

Before today, Lovable was a destination. You opened the browser editor, prompted the agent, watched the preview pane build, and clicked Deploy. The agent lived in Lovable’s window, and your other tools lived everywhere else.

Lovable spent late 2025 inverting half of that. In November 2025 they shipped chat connectors — MCP support that lets the Lovable agent read Notion, Linear, Jira, Confluence, n8n, Miro, Sentry, and a dozen more. That made Lovable an MCP client. The agent stays inside Lovable’s window; the context flows in.

Today’s launch flips the other half. The Lovable MCP server makes Lovable an MCP server — so the agent flows out. Claude Code in your terminal, Cursor in your editor, ChatGPT on your phone, all of them can now call Lovable’s tools without opening the browser editor. The pitch is exactly the symmetry: one protocol, both directions, one product surface.

Mental model: the four named pieces

Once you have these four pieces, the rest of the docs is a deeper read of one of them.

┌──────────────┐                  ┌─────────────────────────────┐
│  Claude      │                  │   mcp.lovable.dev           │
│  Cursor      │ ── streamable ──▶│                             │
│  ChatGPT     │      http        │   ┌─────────────────────┐   │
│  Codex (soon)│ ◀── tool result ─│   │  OAuth or lov_ key  │   │
└──────────────┘                  │   └─────────────────────┘   │
                                  │            │                │
                                  │            ▼                │
                                  │   ┌─────────────────────┐   │
                                  │   │  50+ tools          │   │
                                  │   │  ─────────────      │   │
                                  │   │  projects · agent   │   │
                                  │   │  code · knowledge   │   │
                                  │   │  database · MCPs    │   │
                                  │   │  analytics · upload │   │
                                  │   └─────────────────────┘   │
                                  │            │                │
                                  │            ▼                │
                                  │   Lovable workspace credits │
                                  └─────────────────────────────┘

• The endpoint — one URL, https://mcp.lovable.dev, hosted by Lovable. Streamable HTTP transport. You don’t deploy anything.
• The auth layer — OAuth in the browser on first connect for desktop clients, or an API key prefixed lov_ in the Lovable-API-Key header for headless or scripted use. Scope is the entire workspace, not a single project.
• The tool surface — about fifty tools spread across eight categories: projects, agent interaction, code inspection, knowledge, cloud database, connected MCP servers, analytics, file uploads. Inventory in the next section.
• The credit billing — tools that call the Lovable agent (create_project, send_message) debit your workspace credit balance just like in-editor prompts. Read-only tools cost nothing. Pro plan ships with 100 credits a month.

One more concept matters before setup: scope. The MCP server hands the calling client access to every project in the workspace. There is no per-project token. If you wire an autonomous agent to your main workspace, it can read, write, and deploy anything in there. Use a dedicated test workspace until you trust the loop.

Smallest end-to-end example

Five steps to a working setup, then one prompt to prove it works.

Setup in Claude Code

One command in your terminal:

claude mcp add --transport http lovable "https://mcp.lovable.dev"

Claude Code will open a browser the first time it calls the server. Authorize on the Lovable OAuth screen. Tools show up in the next session.

Setup in Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%/Claude/claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "lovable": {
      "type": "http",
      "url": "https://mcp.lovable.dev"
    }
  }
}

Restart Claude Desktop. OAuth fires on the first tool call.

Setup in Cursor

Cursor needs an explicit OAuth client ID. The docs publish one:

{
  "mcpServers": {
    "lovable": {
      "type": "http",
      "url": "https://mcp.lovable.dev",
      "auth": {
        "CLIENT_ID": "6d465f583e1e4ce5801b1616f735670c"
      }
    }
  }
}

Headless (CI, scripts, server agents)

Generate an API key from your workspace under Settings → API keys. The key starts with lov_. Send it on every request:

Lovable-API-Key: lov_your-api-key-here

The header bypasses the OAuth flow entirely — useful for cron, background agents, and headless continuous-deploy hooks.

Your first real prompt

Once connected, ask Claude (or Cursor) something like:

List my Lovable projects, find the one called "checkout-poc",
show me the diff from the last edit, then deploy it.

What happens behind the chat:

• Claude calls list_projects with a search filter. Free.
• Claude calls list_edits on the matching project. Free.
• Claude calls get_diff with the latest message ID. Free.
• Claude shows you the diff inline and asks for confirmation.
• On yes, Claude calls deploy_project. Returns the live URL. Free (deploy itself doesn’t consume credits; the underlying agent run that produced the build did).

Total cost: zero credits if the project was already built. If the prompt asked Claude to make a change first via send_message, that single agent call debits credits at the same rate as an in-editor prompt — roughly 0.5 to 1.5 credits per ask, per Lovable’s current credit math.

The 50+ tools, organized

The full surface is large but the categories are tight. Here is the lineup straight from the docs.

Opinion: the under-priced tools are the read-only ones. list_projects, get_diff, list_files, read_file, get_project_analytics — all free, all give Claude an instant audit surface across every project you own. The interesting workflows aren’t about spending credits. They’re about asking cross-project questions you couldn’t answer inside the Lovable editor — which of my 12 projects use Supabase auth?which one had the regression in last Tuesday’s edit? Claude can answer those for free; the editor cannot.

Chat connectors vs the MCP server

Lovable now has two MCP-shaped surfaces and the names blur together. Keep them straight.

Same protocol, opposite arrows. The chat-connector catalog at last count includes Amplitude, Atlassian (Jira, Confluence), Confidence, Granola, Hex, HeyGen, Linear, Miro, Notion, n8n, Polar, PostHog, Sanity, and Sentry. Useful when the Lovable agent needs context; irrelevant if you’re trying to drive Lovable from outside.

Real workflows you can build today

Five workflows worth wiring up in the first week.

1. Cross-project audit from your terminal

Claude Code with the Lovable MCP installed answers questions the Lovable editor can’t. List every project that touched supabase.auth in the last 30 days. Show me the projects without a custom domain set. Which workspace knowledge entries reference the old payments provider? Pure read-only, cross-workspace, free.

2. Spec-to-app from a Notion brief

Claude reads a Notion doc (via the official Notion MCP), extracts the requirements, and calls create_project with the brief as the initial message. The Lovable agent does the build inside the container. Claude polls get_message, fetches the diff, summarizes, and offers to deploy.

3. CI hook that QAs every Lovable deploy

A GitHub Action with a lov_ API key calls list_edits on a deploy, pulls get_diff + key read_file contents, and runs them through a Codex CLI test suite. If the Lovable agent regressed your checkout flow, you find out before the live URL goes public.

4. Database migration from the IDE

Cursor with the MCP installed lets you craft a SQL migration in your editor, run it via query_database, see the result inline, and only commit the migration to the project when the run succeeds. The Lovable Cloud database becomes a first-class IDE target instead of a browser tab.

5. Remix-and-customize from a template gallery

Claude calls list_template_projects, presents three options, and on your pick fires remix_project — gets you a clone in your workspace — then send_message with your customization brief. The whole onboarding-from-template flow happens in chat, no UI clicks.

What I got wrong

Three assumptions that turned out to be wrong.

1. I thought the API key was per-project. It isn’t. The lov_ key scopes to the whole workspace. Every project, every database, every edit history, every analytics endpoint. Treat the key like a workspace owner credential, not a feature toggle. If you’re wiring it into an autonomous agent, do it in a separate workspace and pay $25 a month to keep blast radius small.

2. I assumed read-only tools were always free. They are — until you chain them.list_projects with a wide filter on a workspace with 50 projects can pull a meaningful payload that your client’s context window has to hold. The cost isn’t Lovable credits, it’s Claude / Cursor / ChatGPT input tokens. Filter aggressively and page through results.

3. I treated “Research Preview” as “mostly stable, like a beta.” It isn’t. The docs are explicit: “Tool names, parameters, and response shapes may change without notice, including breaking changes.” Don’t bake the tool list into a CLI you ship to customers yet. Write a thin adapter layer in your client code so a rename means one file edit, not twelve.

Common mistakes

Cost & credits, in practice

Lovable’s credit model is granular as of mid-2025: minor edits cost as little as 0.5 credits, complex builds 1.5+. Pro ships 100 credits a month for $25; Business ships 100 credits for $50 with team features. Top-ups are $15 per 50 credits on Pro.

From the MCP server, what costs what:

• Free: all list_*, get_* read-only tools, get_diff, read_file, get_project_analytics, set_project_knowledge, list_mcp_catalog, deploy itself.
• Credits: create_project (initial agent run), send_message (every prompt that runs the agent).
• Token-bound (your client’s side): every tool returns JSON your client adds to its own context window. Big payloads — full file trees, long diff blobs — cost Claude or Cursor input tokens, not Lovable credits. The cheap tools can still bloat your client.

Practical budget: a 30-minute Lovable-driven prototyping session from Claude Code burned 8–12 credits in my test — comparable to running the same flow inside the Lovable editor. The MCP doesn’t add a markup; it just lets you call from a different surface.

Who this is for, who it isn’t

Community signal

Lovable announced the launch on X today. The tweet is short and concrete — the kind of launch post that tells you they want developers paying attention, not the usual marketing copy.

The launch sits on top of six months of MCP scaffolding. In November 2025, Lovable opened the inbound side — their chat connectors let the agent read Notion, Linear, Jira, and Confluence. Notion celebrated that launch:

Today’s launch is the symmetric piece. The community had been wiring the inverse for months — Prajwal Tomar’s Despia integration is one representative example: an MCP that takes a Lovable web app and ships it as an App Store / Play Store mobile app.

The contrarian voice deserves equal airtime. In April 2026, Lovable spent 48 days with a BOLA vulnerability that exposed source code, Supabase credentials, and AI chat histories on projects created before November 2025. Lovable’s response post acknowledged the issue and patched it. None of that is the MCP server’s fault, but it sets the trust weather. The MCP server hands a third-party AI agent workspace-wide write access. That’s a meaningful uplift in capability and a meaningful uplift in blast radius. Use a separate workspace until you trust the loop.

The verdict

The bigger picture

Three trends converge at this launch.

App builders are becoming MCP servers. Replit, v0, Bolt, and now Lovable each have a story for exposing their build surface to other agents. The day where you pick your AI app builder by which integrates with your terminal is closer than the day where you pick it by who has the prettiest preview pane.

Workspace-scoped tokens are a 2026 question. Lovable’s lov_ key joins github_pat_, sk-, and a dozen other broad-scope tokens that AI agents are now allowed to wield. The next year will tell us whether the industry settles on per-project OAuth scopes or just accepts that agent credentials are workspace credentials. The security incidents of 2026 argue for the former; the product velocity of 2026 argues for the latter.

The IDE is becoming the universal AI surface. Claude Code can now drive your design tool (Stitch), your video tool (Pika), your ad platform (Meta Ads), your image stack (Higgsfield), and now your app builder (Lovable). Every “product” in 2026 ships an MCP server because every developer is starting to expect one. Lovable just paid the table-stakes price.

Frequently asked questions

Glossary

All sources

Primary — Lovable

• Lovable MCP server docs — endpoint, OAuth flow, tool surface, plan requirements, Research Preview disclaimer.
• Chat connectors docs — the inverse direction (Lovable as MCP client).
• What’s new: MCP servers and design power — the November 18, 2025 chat-connector launch.
• Plans and credits — Pro / Business pricing, credit math.

Community and analysis

• Lovable on X — MCP server launch tweet (May 7, 2026).
• Notion on X — chat-connector launch reaction.
• Prajwal Tomar on X — Despia × Lovable MCP — community-built integration that ships Lovable apps as native mobile apps.
• hiromima/lovable-mcp-server — unofficial local MCP server for analyzing Lovable projects on disk.

Contrarian and risk

• The Next Web: Lovable security crisis — 48-day BOLA exposure.
• The Register: Lovable denies the data leak — the contested public response.
• Lovable: response to the April 2026 incident — the company’s own framing.
• VibeEval: Vibe Coding Security Weekly — Apr 23 summary.

Internal — on MCP.Directory

• What is the Model Context Protocol? A Developer’s Map
• OAuth 2.1 for remote MCP servers (Streamable HTTP)
• MCP security 2026: OWASP Top 10 + CVEs
• Pika MCP — another official-MCP deep-dive
• Meta Ads MCP and CLI
• Claude Desktop client guide
• Claude Code client guide
• Cursor client guide
• Best MCP servers (2026)
• Remote (hosted) MCP servers
• Browse 3,000+ MCP servers