Build with AI (Lovable, Cursor, Claude)

Connect our docs MCP server to your AI builder and integrate the LMN API without hand-writing the plumbing.

Overview

You need a sandbox key first. Sign up at console.lmnauto.com — work email and company name, auto-approved, key in hand in about five minutes. It carries a 100-call trial budget, which is enough to build and demo an integration but will not survive a page that polls on every render. See Quickstart.

If you build with an AI tool — Lovable, Cursor, Claude Code, or Claude Desktop — you don’t need to paste our docs into prompts. We publish two machine-readable surfaces that keep your AI grounded in the real API instead of guessing:

Asset	URL	What it does
Docs MCP server	https://lmn.mintlify.app/mcp	Lets your AI search and read these docs live while it writes your integration
llms.txt	https://lmn.mintlify.app/llms.txt	One-page docs index for tools that ingest a URL instead of connecting MCP

The MCP server is public and read-only — no key, no OAuth. It searches documentation; it does not call the API or see your data.

The LMN API is server-to-server only. There is no browser CORS support — a website calling api.lmnauto.com directly from frontend JavaScript will fail before the request is sent, and your API key would be exposed to every visitor if it didn’t. All calls must come from a backend (server, serverless function, or edge function) that holds your key privately. Every recipe on this page follows that rule.

Connect the MCP server

Your tool	How to connect
Lovable	Connectors → Chat connectors → New MCP server → paste the URL
Claude Code	claude mcp add --transport http lmn https://lmn.mintlify.app/mcp
Claude Desktop / claude.ai	Settings → Connectors → Add custom connector → paste the URL
Cursor	Settings → MCP → add server with the URL

Once connected, your AI gains a search tool and a docs-reading tool. Ask it anything about the API (“how does authentication work?”, “what does a vehicle object look like?”) and it will answer from the current published docs.

Integrating from Lovable

Lovable generates frontend code and delegates everything server-side to a backend it provisions for you (Lovable Cloud, built on Supabase). Because the LMN API is server-to-server only, that backend is not optional — it’s where your API key lives and where the calls happen.

1. Let Lovable create its backend

   When Lovable asks you to connect Supabase (or enable Lovable Cloud), approve it. This is the step that makes a secure integration possible — if you skip it, Lovable cannot store your key or call our API, and the integration silently goes nowhere.

2. Add the LMN docs connector

   In Lovable: Connectors → Chat connectors → New MCP server → paste https://lmn.mintlify.app/mcp. Now Lovable reads our real endpoint contracts instead of inventing them.

3. Paste the integration prompt

   Use this as your Lovable prompt (edit the page description to taste):

   Add a "Live Inventory" page showing vehicles from the LMN Open API.
   Use the LMN MCP connector to read the API documentation first.
   
   Requirements:
   - FIRST, before building anything: call
     GET https://sandbox-api.lmnauto.com/v1/vehicles?limit=1 from the
     backend with my API key in the x-api-key header and show me the
     response. Only proceed once it returns 200.
   - Create a backend edge function that calls
     https://sandbox-api.lmnauto.com/v1/vehicles with my API key in the
     x-api-key header. Store the key as a backend secret named LMN_API_KEY.
   - Never call the LMN API from the browser and never put the key in
     frontend code. The frontend talks only to the edge function.
   - Show each vehicle's photo, make, model, year, and price, with a
     detail view backed by /v1/vehicles/{id}.
   
4. Add your API key as a secret

   When Lovable asks for LMN_API_KEY, paste your key there and only there. Start with your sandbox key (lmn_stg_*) against sandbox-api.lmnauto.com; switch the base URL and key to production (lmn_prd_*, api.lmnauto.com) once the page works.

5. Verify

   Load the preview. If vehicles render, you’re live. If not, ask Lovable to show the edge function’s response — then check the error code matrix. The two most common first-run failures are a missing x-api-key header and an IP allowlist rejection (below).

IP allowlist: sandbox trial keys have no allowlist — Lovable Cloud, Supabase Edge Functions, and Vercel all work out of the box. Production keys are restricted to registered egress IPs (see Authentication), which serverless platforms with rotating pools cannot satisfy directly. Build and certify on sandbox, then use Request production access in the console and tell us you’re deploying serverless — we’ll plan the egress setup with you rather than leaving you to discover it at cutover.

Watch the trial budget while your AI iterates. Every authenticated call counts against the 100-call budget, including the ones your tool makes while debugging its own code. An agent stuck in a retry loop can burn the whole budget in a minute. Ask it to cache responses during development, and check X-Quota-Remaining on any response — when it hits zero you’ll get 429 rate_limited, which does not clear on its own.

Other AI coding tools

The same shape applies outside Lovable: connect the MCP server, then ask your tool to build a server-side client. For a Next.js app that means an API route or server component; for plain Node, any server process. Keep LMN_API_KEY in environment variables or a secret manager — never in code that ships to a browser.

If something doesn’t work

Email [e-mail] with what your tool generated — the request code and the response body — or message your LMN contact if you have one. Include the request_id from the error envelope (also returned as the X-Request-Id header): it lets us find your exact call in our logs. We can see whether your key’s calls reach us at all, and “nothing arrived” versus “arrived but rejected” points to completely different fixes.