Build with AI (Lovable, Cursor, Claude)

Ask your coding assistant about the LMN API: connect it to our documentation so it reads the real contracts, fixes errors from the docs, and never guesses.

​

Ask your coding assistant about the LMN API

If you build with Lovable, Cursor, Claude Code, Claude Desktop or another coding agent, you do not have to paste our docs into prompts or relay error messages to support. Your assistant can read this documentation itself:

1. Connect your tool to the LMN documentation connector (one URL, no account).
2. Ask it a question — or paste a sanitized error (status code, error.code, error.message, request_id; never your API key).
3. The assistant retrieves the relevant page from this site.
4. It answers from the docs, or corrects the request it generated.

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 1,000-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.

​

What the connector is — and is not

The documentation connector is a public, read-only MCP server that searches and reads this site. Two things to know before you rely on it:

• It needs no API key and never sees your account. It cannot read your partner account, production logs or orders, cannot run live API calls, and cannot place orders. It only reads published documentation.
• Want your team to search live inventory from an assistant instead? That is a different server, the Inventory assistant (MCP): it reads live listings with your API key.
• Discovery is not automatic or guaranteed. You must connect or enable the integration the way your tool supports it (below). Even when connected, the assistant chooses when to search — the instruction block further down tells it to check the docs before generating calls.

Asset	URL	What it does
Docs connector (MCP)	https://lmn.mintlify.app/mcp	Lets your AI search and read these docs live while it writes your integration
Docs index (llms.txt)	https://lmn.mintlify.app/llms.txt	One-page index of every page here — paste it, or a page URL, into your prompt when your tool cannot connect an MCP server

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 connector

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
Anything else	If the tool cannot add an MCP server, paste https://lmn.mintlify.app/llms.txt or the URL of the page you need into the prompt

Once connected, your AI gains a documentation search tool and a page-reading tool. Ask it anything about the API (“how does authentication work?”, “why did source=dealer return 400?”) and it answers from the current published docs.

For filter combinations, production availability, and pagination examples, start with Partner vehicle search filters, then use the Vehicles reference for full parameter details.

​

Tell the assistant to use it

Paste this into your tool’s project instructions (Lovable: project Knowledge; Claude Code: CLAUDE.md; Cursor: Rules). It makes the assistant check the docs before generating calls and admit when the docs do not cover something:

Use the LMN documentation connector when building this integration.
Check the documented requirements before generating API calls.
If a request fails, consult the troubleshooting docs before changing
implementation. If the docs do not answer it, say so rather than guess.
Never include API keys in frontend code or support messages.

​

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. Store your API key as a secret

   Add a Lovable secret named LMN_API_KEY (Project Settings → Secrets) and 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. The prompts below assume the secret already exists — they never contain the key.

4. Paste an integration prompt

   Two prompts, depending on what you are building. The basic prompt renders inventory; the combined storefront prompt builds the auction + dealer page most partners actually want and follows the Combined inventory storefront guide.

   Basic — list and detail:

   I want to integrate the LMN vehicle API into this project.
   
   1. Connect the LMN docs connector at https://lmn.mintlify.app/mcp and read the documentation before writing any API call. If the docs do not answer a question, say so rather than guess.
   2. My API key is already stored as a secret named LMN_API_KEY (Lovable: Project Settings → Secrets). Read it from there. Never hardcode it, never print it, and never put it in frontend code.
   3. BEFORE building anything, verify the key works with a single backend request: GET https://sandbox-api.lmnauto.com/v1/vehicles?limit=1 with header "x-api-key: <LMN_API_KEY>". Show me the HTTP status and response body. Stop if it is not 200.
   4. All requests go to the sandbox base URL https://sandbox-api.lmnauto.com and authenticate with the x-api-key header.
   5. Use the backend-proxy pattern: never call the LMN API from browser code. Route every call through a server-side endpoint you own, so the key never reaches the client.
   6. Add a "Live Inventory" page showing each vehicle's photo, make, model, year and listing price from GET /v1/vehicles, with a detail view backed by GET /v1/vehicles/{id}.
   7. When something fails, show me the HTTP status, error.code, error.message and request_id from the response, and check https://lmn.mintlify.app/troubleshooting-dealer-listings before changing the implementation.
   

   Combined auction + dealer storefront:

   Build a "Vehicle inventory" page that combines LMN auction listings and dealer (fixed-price) listings. Read the guide at https://lmn.mintlify.app/combined-inventory-storefront through the LMN docs connector (https://lmn.mintlify.app/mcp) before writing code.
   
   Rules the guide requires — do not skip any:
   - My API key is already stored as a secret named LMN_API_KEY (Lovable: Project Settings → Secrets). Read it from there; never put it in frontend code.
   - Every LMN call runs in a backend function against https://sandbox-api.lmnauto.com with the x-api-key header. The browser only talks to that function.
   - Verify first: GET /v1/vehicles?limit=1 from the backend must return 200 before you build anything.
   - Load filter values from GET /v1/vehicles/facets (makes and models for both sources) and GET /v1/vehicles/facets?source=dealer (sub_models). Never invent make or model names.
   - Auction and dealer are two separate requests. Omitting source returns auctions only. Dealer rows need source=dealer. Make is optional: omit make to search all brands. Model requires make; clear model and sub_model when clearing make.
   - Build each request from its own filter whitelist. Never send auction_status, auction_date_from, auction_date_to, accident_grade, exterior_grade, auction_count_min, auction_count_max or orderable_only to the dealer request, and never send sub_model to the auction request.
   - Keep one cursor per source. Reset both cursors on any filter or sort change. Never pass cursor with a mixed source list.
   - Merge the two pages client-side: dedupe by id, label every card with its source, and do not claim a global sort order across sources.
   - Show failures and empty results differently. A non-2xx response or a thrown fetch must render an error state with the HTTP status, error.code and request_id — never "No vehicles found". Also surface source_status when encar is stale, partial or unavailable.
   - Cards show pricing.listing_price labelled as the listing price and pricing.breakdown.estimated_landed labelled as the estimated landed cost, both in whole USD. Missing values show "Unknown".
   - When done, walk me through the acceptance checklist in the guide and show the actual responses for each check.
   
5. Verify — against the checklist, not the screen

   Auction cards rendering proves the auction request works. It proves nothing about dealer listings, pagination, or failure handling. Work through the integration acceptance checklist — it checks each source, each cursor, filter resets, and the failure state separately. If something fails, ask Lovable to show the backend function’s actual response (status, error.code, request_id), then use Missing dealer listings and the error code matrix.

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 1,000-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 connector, store LMN_API_KEY where your tool keeps secrets (a gitignored .env, the Replit Secrets pane, your platform’s secret manager), then paste the same prompts. For a Next.js app the backend is an API route or server component; for plain Node, any server process. Never put the key in code that ships to a browser.

​

If something doesn’t work

First ask your assistant to show you the real response — the HTTP status and the full error body — and to check Missing dealer listings and the error code matrix. Most first-run failures are a missing x-api-key header, a model filter without its parent make, or an auction-only filter sent to a dealer request.

If the docs do not resolve it, email [e-mail] (or message your LMN contact) with this template. It lets us find your exact call in our logs and tell “nothing arrived” from “arrived but rejected” in one look:

What I expected: <one sentence — e.g. "dealer BMW listings on the inventory page">
Environment: sandbox | production
Request: <method + path + sanitized query, e.g. GET /v1/vehicles?source=dealer&make=BMW&limit=24>
Response: HTTP <status>, error.code=<code>, request_id=<req_…>
Error body: <paste the JSON error object>
Backend code: <the function that builds and sends the request, with the key removed>

Never send your API key — not in email, chat, screenshots or prompts. We cannot use it, and if one reaches us we will ask you to rotate it from the console. The request_id (also returned as the X-Request-Id header) is all we need to find your call.