# Documentation > Welcome to CarsXE API's documentation. Source: https://carsxe.com/docs Learn everything there is to know about CarsXE API and integrate CarsXE into your product. #### Getting started To get started, [sign in or create an account](https://carsxe.com/signin) and grab an API key, then read about how to make requests for the resources you need to access using our HTTP APIs. ## Guides

### Quickstart Get a quick start integrating the API into your application. ### Authentication Learn how to authenticate your API requests. ### Organizations Share API access with your team using roles and organization API keys. ### Errors Read about the different types of errors returned by the API. ### Industry Guides Discover best practices and step-by-step examples for leveraging the CarsXE API across different industries. ### Agents & AI Get an API key, read docs, and make calls — all from inside your AI agent. ### Latency & Regions Learn about API regions and how to reduce latency from Europe using the EU endpoint.

## API Reference Select a resource to learn more about it.

### Specifications Learn about the Vehicle Specifications API and how to retrieve vehicle specifications from VINs. ### Plate Decoder Learn about the Vehicle Plate Decoder API and how to retrieve vehicle specifications from license plates and vehicle registrations. ### Images Learn about the Vehicle Images API and how to retrieve vehicle images. ### Market Value Learn about the Market Value API and how to retrieve vehicle market values from VINs. ### International VIN Decoder Learn about the International VIN Decoder API and how to retrieve vehicle specifications from international VINs. ### Recalls Learn about the Vehicle Recalls API and how to search for safety recalls based on a vehicle's VIN. ### History Learn about the Vehicle History API and how to retrieve vehicle history reports from VINs. ### VIN OCR Learn about the VIN Optical Character Recognition API and how to quickly identify a vehicle's VIN from an image. ### Market Value (v1) Learn about the v1 Market Value API and how to retrieve vehicle market value estimates from VINs. ### Lien & Theft Learn about the Lien & Theft API and how to check for active liens and theft records on a vehicle. ### Recalls Batch Learn about the Recalls Batch API and how to search safety recalls for many VINs in a single request. ### Plate Image Recognition Learn about the Plate Image Recognition API and how to detect and read license plates from image URLs. ### Year Make Model Learn about the Year Make Model API and how to look up vehicle attributes by year, make, model, and trim. ### OBD Codes Decoder Learn about the OBD Codes Decoder API and how to decode OBD-II diagnostic trouble codes.

--- # Agents & AI > Everything you need to use CarsXE vehicle data APIs from AI coding agents, LLMs, and automated pipelines — including browser-based onboarding, machine-readable documentation, and content negotiation. Source: https://carsxe.com/docs/agents CarsXE is built to be agent-friendly. Whether you are a coding agent onboarding a new project, an LLM reasoning about vehicle data, or an automation pipeline calling REST endpoints, this page covers the features we ship specifically for AI and agent use cases. --- ## Browser-based agent onboarding Getting a CarsXE API key from inside any AI agent — Claude Code, Claude Desktop, Cursor, Codex CLI, Gemini CLI, or any other coding assistant — takes just a few steps with no CLI install required. The agent directs you to a browser page, waits for you to authorize, then retrieves and stores your key automatically. The complete machine-readable skill document for agents is available at `https://carsxe.com/agent-onboarding/SKILL.md`. Agents that support skill discovery (such as Claude Code) will pick this up automatically. ### Step 1 — Give your agent the onboarding skill Pass the skill document URL to your agent so it knows exactly how to authenticate: > "Use this skill to get a CarsXE API key: https://carsxe.com/agent-onboarding/SKILL.md" The agent fetches the skill, generates secure session parameters, then presents you with a clickable link to open in your browser. ### Step 2 — Authorize in the browser Click the link the agent provides. You will be taken to the CarsXE authorization page where you can sign in or create an account and approve access. No typing required — just click **Authorize**. ### Step 3 — Your agent retrieves the key Once you click Authorize, the agent polls in the background and retrieves your API key. It stores it automatically (typically as `CARSXE_API_KEY` in your environment or project `.env` file). ### Step 4 — Start making calls Your agent can immediately start making vehicle data calls on your behalf: > "Decode VIN WBAFR7C57CC811956" > "What is the market value of this vehicle with 50,000 miles?" > "Check for any open recalls." --- ## Machine-readable documentation (`Accept: text/markdown`) CarsXE documentation pages support HTTP content negotiation. Send `Accept: text/markdown` on any documentation, support, or guide page to receive clean Markdown instead of HTML — fewer tokens, no layout markup, and higher signal for RAG pipelines and LLM context windows. ### How to use it ```bash # Any docs page as Markdown curl -H "Accept: text/markdown" https://carsxe.com/docs/quickstart # Specific API reference page curl -H "Accept: text/markdown" https://carsxe.com/docs/v1/specifications # Direct Markdown endpoint — no content negotiation needed curl https://carsxe.com/api/markdown/docs/v1/specifications ``` ### Supported content types The site produces two content types: | Type | Description | | --------------- | ------------------------------------------------ | | `text/html` | Default browser response | | `text/markdown` | Clean Markdown — no layout, no navigation chrome | If the `Accept` header explicitly excludes both (for example `Accept: application/pdf`), the server returns `406 Not Acceptable` with a plain-text body listing the available types. ### The `Vary: Accept` header All responses include `Vary: Accept` so HTTP caches store separate entries for the HTML and Markdown representations of the same URL. ### The `Link: rel="alternate"` header HTML responses on documentation, support, and guide pages include a `Link` header advertising the direct Markdown URL. Agents that inspect response headers can discover the Markdown endpoint without making a second request. ```bash Link: ; rel="alternate"; type="text/markdown" Vary: Accept ``` ### Direct Markdown endpoint The `/api/markdown/[[...slug]]` route serves `text/markdown` unconditionally — no `Accept` header required. Use it when you want to hard-code the Markdown URL in a retrieval pipeline or a prompt template. ```bash curl https://carsxe.com/api/markdown/docs/quickstart curl https://carsxe.com/api/markdown/docs/authentication curl https://carsxe.com/api/markdown/docs/v1/specifications curl https://carsxe.com/api/markdown/docs/v2/market-value curl https://carsxe.com/api/markdown/support/ARTICLE_SLUG curl https://carsxe.com/api/markdown/guides/GUIDE_SLUG ``` Responses include `Cache-Control: s-maxage=300, stale-while-revalidate=86400` and `Vary: Accept`. --- ## Site index for LLMs (`llms.txt`) The site exposes a machine-readable index at `/llms.txt`. This document provides a plain-text overview of CarsXE for language models — product description, all API endpoints with pricing, subscription tiers, quick links, and recent blog posts. It is generated on each request with live pricing data so models always see current overage rates and tier names. ```bash curl https://carsxe.com/llms.txt ``` --- ## Making API calls from an agent All endpoints accept `key=YOUR_API_KEY` as a query parameter — the same environment variable the onboarding flow stores. POST endpoints also send the body as JSON with `Content-Type: application/json`. ### Vehicle Specifications (VIN Decode) Decode a VIN and retrieve full vehicle specifications: make, model, year, engine, trim, equipment, and more. See [full reference](https://carsxe.com/docs/v1/specifications). ```bash curl -G https://api.carsxe.com/specs \ -d key=YOUR_API_KEY \ -d vin=WBAFR7C57CC811956 ``` ### Market Value Estimate retail, trade-in, and auction values for a vehicle by VIN, with optional mileage, state, and condition adjustments. See [full reference](https://carsxe.com/docs/v2/market-value). ```bash curl -G https://api.carsxe.com/v2/marketvalue \ -d key=YOUR_API_KEY \ -d vin=WBAFR7C57CC811956 \ -d mileage=50000 \ -d state=CA \ -d condition=clean ``` ### Vehicle History Retrieve a comprehensive history report including title records, junk/salvage events, and insurance information for a VIN. See [full reference](https://carsxe.com/docs/v1/history). ```bash curl -G https://api.carsxe.com/history \ -d key=YOUR_API_KEY \ -d vin=WBAFR7C57CC811956 ``` ### Vehicle Recalls Check for open safety recalls associated with a VIN. See [full reference](https://carsxe.com/docs/v1/vehicle-recalls). ```bash curl -G https://api.carsxe.com/v1/recalls \ -d key=YOUR_API_KEY \ -d vin=WBAFR7C57CC811956 ``` ### Lien & Theft Check Check whether a vehicle has active liens or has been reported stolen. See [full reference](https://carsxe.com/docs/v1/lien-theft). ```bash curl -G https://api.carsxe.com/v1/lien-theft \ -d key=YOUR_API_KEY \ -d vin=WBAFR7C57CC811956 ``` ### Plate Decoder Look up a vehicle by license plate number. Supports 50+ countries. See [full reference](https://carsxe.com/docs/v2/plate-decoder). ```bash curl -G https://api.carsxe.com/v2/platedecoder \ -d key=YOUR_API_KEY \ -d plate=7XER187 \ -d country=US \ -d state=CA ``` ### International VIN Decoder Decode a non-US VIN from European, Asian, and other markets. See [full reference](https://carsxe.com/docs/v1/international-vin-decoder). ```bash curl -G https://api.carsxe.com/v1/international-vin-decoder \ -d key=YOUR_API_KEY \ -d vin=WF0MXXGBWM8R43240 ``` ### Vehicle Images Retrieve vehicle photos by make, model, and year. Supports filtering by color, angle, photo type, and size. See [full reference](https://carsxe.com/docs/v1/images). ```bash curl -G https://api.carsxe.com/images \ -d key=YOUR_API_KEY \ -d make=BMW \ -d model=5-Series \ -d year=2012 ``` ### Year / Make / Model Look up vehicle data when you don't have a VIN — search by year, make, and model instead. See [full reference](https://carsxe.com/docs/v1/year-make-model). ```bash curl -G https://api.carsxe.com/v1/ymm \ -d key=YOUR_API_KEY \ -d year=2012 \ -d make=BMW \ -d model=5-Series ``` ### Plate Image Recognition Extract and decode a license plate number from an image URL. See [full reference](https://carsxe.com/docs/v1/plate-image-recognition). ```bash curl -X POST "https://api.carsxe.com/platerecognition?key=YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"image_url": "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"}' ``` ### VIN OCR Extract a VIN from a photo of a VIN plate or dashboard sticker. See [full reference](https://carsxe.com/docs/v1/vin-ocr). ```bash curl -X POST "https://api.carsxe.com/v1/vinocr?key=YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"image_url": "https://user-images.githubusercontent.com/5663423/30922082-64edb4fa-a3a8-11e7-873e-3fbcdce8ea3a.png"}' ``` ### OBD Codes Decoder Decode a diagnostic trouble code (DTC) from an OBD-II scanner — over 3,000 codes supported. See [full reference](https://carsxe.com/docs/v1/obd-codes-decoder). ```bash curl -G https://api.carsxe.com/obdcodesdecoder \ -d key=YOUR_API_KEY \ -d code=P0300 ``` --- ## MCP server for AI tools For interactive AI editors and chat clients (Claude Desktop, Cursor, VS Code, Windsurf), the CarsXE MCP server is the recommended integration path — it exposes all endpoints as named tools and formats responses as Markdown automatically. See the [MCP Quickstart Guide](https://carsxe.com/docs/integrations/mcp-quickstart) for installation instructions for each editor. --- ## What's next? - [Agent onboarding skill document](https://carsxe.com/agent-onboarding/SKILL.md) — machine-readable PKCE auth flow - [llms.txt](https://carsxe.com/llms.txt) — full site index for LLMs - [MCP Quickstart](https://carsxe.com/docs/integrations/mcp-quickstart) — MCP server for Claude, Cursor, VS Code, Windsurf - [Claude Code Plugin](https://carsxe.com/docs/integrations/claude-quickstart) — slash commands and auto-invoked skills - [CLI Quickstart](https://carsxe.com/docs/integrations/cli-quickstart) — terminal tool for agent-driven shell workflows - [Authentication](https://carsxe.com/docs/authentication) — API key management - [Quickstart](https://carsxe.com/docs/quickstart) — first API call walkthrough --- # Authentication > In this guide, we’ll look at how authentication works. CarsXE offers one way to authenticate your API requests, Basic authentication. Source: https://carsxe.com/docs/authentication You'll need to authenticate your requests to access any of the CarsXE API endpoints. In this guide, we'll look at how authentication works. CarsXE offers a very simple way to authenticate with an API key. You can find your API key on the [dashboard](https://carsxe.com/dashboard). ## API key With basic authentication, you use your API key to authenticate your HTTP requests. Here's how to authenticate using cURL: ```bash curl https://api.carsxe.com/v1/auth/validate \ -d key=CARSXE_API_KEY \ ``` Please don't commit your CarsXE API key to GitHub! --- # Errors > Every error the CarsXE API returns — what it means, why it happened, and how to fix it. Includes the error envelope, status codes, and retry guidance. Source: https://carsxe.com/docs/errors This page is a complete reference for every error the CarsXE API can return. Each entry explains **why the error happened** and **how to fix it**, so you can resolve most issues without contacting support. You can tell whether a request succeeded from the HTTP status code. Every response body also includes a `success` boolean, so you can check either one. --- ## The error envelope All errors share the same JSON shape: Always false for errors. Successful responses return true. A human-readable description of what went wrong. Messages are stable strings — you can match on them — but prefer matching on the HTTP status code where possible. Present only on 429 quota errors. Contains current, limit, and remaining so you can see exactly where you stand. See [Rate Limits & Quotas](https://carsxe.com/docs/rate-limits). A few legacy v1 routes return a 500 status for validation problems (for example, a missing make/model on the Images API). Always check the success field in addition to the status code when working with v1 endpoints. v2 endpoints use precise status codes throughout. --- ## Status codes | Status | Meaning | Safe to retry? | | --- | --- | --- | | `200` | Success. | — | | `202` | Accepted — an async job (e.g. [Recalls Batch](https://carsxe.com/docs/v1/recalls-batch)) was queued. Poll its status endpoint. | — | | `400` | Bad request — a parameter is missing or invalid. | No — fix the request first. | | `401` | Authentication failed — missing, invalid, or inactive API key. | No — fix your key or billing. | | `403` | Forbidden — your key is blocked or your plan doesn't include this API. | No | | `404` | Not found — no data exists for this VIN/plate, or an invalid state/country code. | No — same input returns the same result. | | `405` | Method not allowed — e.g. `GET` sent to a `POST`-only endpoint. | No — change the HTTP method. | | `429` | Usage quota exceeded. | Not as-is — quota errors persist until you upgrade, enable overage, or the period resets. See [Rate Limits & Quotas](https://carsxe.com/docs/rate-limits). | | `500` | Internal server error. | Yes — once, with backoff. If persistent, contact support. | | `502` | Upstream data provider could not be reached. | Yes — with backoff. | | `503` | Upstream provider temporarily unavailable. | Yes — with backoff. | | `504` | Upstream request timed out. | Yes — with backoff. | --- ## Authentication errors | Message | Status | Why it happened | How to fix it | | --- | --- | --- | --- | | `Missing API key` | `401` | The request did not include the `key` parameter. | Pass your API key as the `key` query parameter on every request. See [Authentication](https://carsxe.com/docs/authentication). | | `User with this API key was not found or the API key is disabled` | `401` | The key has a typo, was revoked, or was disabled. | Copy the key again from your [dashboard](https://carsxe.com/dashboard). Check for whitespace or truncation. | | `User with this API key is not active. To activate update your billing on https://carsxe.com/dashboard/billing` | `401` | A payment failed or your billing is not in good standing, so API access was suspended. | Update your payment method on the [billing page](https://carsxe.com/dashboard/billing). Access resumes immediately after. | | `This API key has been blocked, please contact support if you believe this is an error.` | `403` | The key was flagged for abuse. | Contact support with your account email. | | `This API is not available for your current subscription tier. Visit https://carsxe.com/pricing to review upgrade options.` | `403` | Your plan does not include this endpoint. | Compare plans on the [pricing page](https://carsxe.com/pricing) and upgrade, or remove the call. | --- ## Validation errors These are returned before any lookup happens, so they don't count against your quota. Fix the request and resend. | Message | Status | How to fix it | | --- | --- | --- | | `Missing vin (vehicle identification number)` | `400` | Pass the `vin` parameter. | | `Wrong VIN length, must be 17 characters` | `400` | VINs are exactly 17 characters. Strip whitespace; check for `O`/`0` and `I`/`1` transcription mistakes. | | `Missing vehicle registration number or license plate number` | `400` | Pass the `plate` parameter. | | `Missing 2 letter state code` | `400` | Pass `state` as a 2-letter code (e.g. `CA`). Required for US plate lookups. | | `Invalid state or country code.` | `404` | Use ISO-style 2-letter codes. See the supported-country list on the [Plate Decoder page](https://carsxe.com/docs/v2/plate-decoder). | | `Invalid condition. Available conditions: excellent, clean, average, rough` | `400` | The `condition` parameter on [Market Value v2](https://carsxe.com/docs/v2/market-value) accepts only those four values. | | `Invalid mileage. Must be a number` | `400` | Pass `mileage` as digits only — no commas or units. | | `Missing image data` | `400` | VIN OCR and Plate Recognition need an image — pass a URL or base64 string. | | `Invalid image data format. Must be a valid URL or base64 encoded string.` | `400` | Check the URL is publicly reachable, or that the base64 payload is complete. | | `Please supply a make and model. Visit https://carsxe.com/docs for more information` | `500` | The Images API requires both `make` and `model`. (Legacy route — note the 500 status.) | The [Recalls Batch](https://carsxe.com/docs/v1/recalls-batch) endpoints have additional validation rules (VIN count, CSV size and hosting, webhook URLs) — those messages are self-describing and documented on the batch page. --- ## Data not found A `404` with one of these messages means the request was valid, but no data exists for that vehicle. Retrying the same input returns the same result. | Message | How to fix it | | --- | --- | | `No data found for this VIN` | Verify the VIN is correct. Coverage varies by market and model year. | | `No data found for this VIN. Try a deep search by setting deepdata=1 in your request` | Retry with `deepdata=1` on the [Specifications API](https://carsxe.com/docs/v1/specifications) for an extended-source lookup. | | `Plate searches for this country have been disabled, or No data found for this plate` | Check the plate and region. Some countries are unavailable; see the coverage list on the Plate Decoder page. | | `No lien or theft data found for this VIN` | No records exist — for many use cases this is the answer you want. | | `No images found` | Try a less specific query (drop `trim` or `color`). | | `No plates detected in image` | Use a sharper, better-lit image where the plate is clearly visible. | | `No valid VIN candidates found in the image` / `No text detected in the image` | Use a higher-resolution image of the VIN plate or windshield etching. | Not-found results for VIN lookups are cached for about one day. If you believe data should exist, wait before retrying rather than hammering the endpoint with the same VIN. --- ## Rate limit and quota errors A `429` means you've used up your plan's included volume for this API: See [Rate Limits & Quotas](https://carsxe.com/docs/rate-limits) for how limits work, the exact response shapes, and backoff strategies. --- ## Server and upstream errors CarsXE aggregates data from multiple providers. When a provider fails or times out, you'll see one of these: | Message | Status | What it means | What to do | | --- | --- | --- | --- | | `Internal server error` | `500` | An unhandled error on our side. | Retry once with backoff. If it persists, contact support with the endpoint, parameters, and timestamp. | | `Unable to authenticate internal request (code CV-001). Please try again later` | `500` | An internal provider credential issue — not your request. | Retry later. Quote the `CV-001` code to support if it persists. | | `Unable to authenticate internal request (code CV-002). Please try again later` | `500` | Same as above, for the History API. | Retry later. Quote `CV-002` to support. | | `Could not fetch data` | `502` | The upstream provider was unreachable or returned an error. | Retry with exponential backoff. | | `Cannot access the internet at this time` | `503` | The upstream provider is temporarily down. | Retry with backoff. | | `Request timed out. Please try again.` | `504` | The provider didn't respond in time. | Retry with backoff — these are usually transient. | --- ## Handling errors in code Check `response.ok` / the status code first, then branch on the category. Retry only `5xx` — a `4xx` (including quota `429`s, which persist until you upgrade or enable overage) needs a fix, not a retry: ```bash CARSXE_API_KEY="CARSXE_API_KEY" URL="https://api.carsxe.com/specs?key=${CARSXE_API_KEY}&vin=1HGCM82633A004352" retries=3 for attempt in $(seq 0 $retries); do response=$(curl -s -w "\n%{http_code}" "$URL") body=$(echo "$response" | sed '$d') status=$(echo "$response" | tail -n 1) if [ "$(echo "$body" | jq -r '.success')" = "true" ]; then echo "$body" exit 0 fi # 4xx: fix the request (or your quota) — retrying won't help if [ "$status" -lt 500 ]; then echo "CarsXE $status: $(echo "$body" | jq -r '.message')" >&2 exit 1 fi # 5xx: exponential backoff if [ "$attempt" -lt "$retries" ]; then sleep $((2 ** attempt)) fi done echo "CarsXE request failed after retries" >&2 exit 1 ``` ```js async function carsxeRequest(url, { retries = 3 } = {}) { for (let attempt = 0; attempt <= retries; attempt++) { const res = await fetch(url); const body = await res.json(); if (body.success) return body; // 4xx: fix the request (or your quota) — retrying won't help if (res.status < 500) { throw new Error(`CarsXE ${res.status}: ${body.message}`); } // 5xx: exponential backoff if (attempt < retries) { await new Promise((r) => setTimeout(r, 2 ** attempt * 1000)); } } throw new Error('CarsXE request failed after retries'); } ``` ```python import time import httpx def carsxe_request(url: str, params: dict, retries: int = 3) -> dict: for attempt in range(retries + 1): res = httpx.get(url, params=params) body = res.json() if body.get("success"): return body # 4xx: fix the request (or your quota) — retrying won't help if res.status_code < 500: raise RuntimeError(f"CarsXE {res.status_code}: {body['message']}") # 5xx: exponential backoff if attempt < retries: time.sleep(2 ** attempt) raise RuntimeError("CarsXE request failed after retries") ``` ```php get($path, ['query' => $query, 'http_errors' => false]); $body = json_decode((string) $res->getBody(), true); $status = $res->getStatusCode(); if ($body['success'] ?? false) { return $body; } // 4xx: fix the request (or your quota) — retrying won't help if ($status < 500) { throw new RuntimeException("CarsXE {$status}: {$body['message']}"); } // 5xx: exponential backoff if ($attempt < $retries) { sleep(2 ** $attempt); } } throw new RuntimeException('CarsXE request failed after retries'); } ``` ```ruby require 'json' require 'net/http' require 'uri' def carsxe_request(url, retries: 3) uri = URI(url) (0..retries).each do |attempt| res = Net::HTTP.get_response(uri) body = JSON.parse(res.body) return body if body['success'] # 4xx: fix the request (or your quota) — retrying won't help if res.code.to_i < 500 raise "CarsXE #{res.code}: #{body['message']}" end # 5xx: exponential backoff sleep(2**attempt) if attempt < retries end raise 'CarsXE request failed after retries' end ``` ```go package main import ( "encoding/json" "fmt" "io" "net/http" "time" ) func carsxeRequest(url string, retries int) (map[string]any, error) { for attempt := 0; attempt <= retries; attempt++ { res, err := http.Get(url) if err != nil { return nil, err } bodyBytes, _ := io.ReadAll(res.Body) res.Body.Close() var body map[string]any if err := json.Unmarshal(bodyBytes, &body); err != nil { return nil, err } if success, _ := body["success"].(bool); success { return body, nil } // 4xx: fix the request (or your quota) — retrying won't help if res.StatusCode < 500 { return nil, fmt.Errorf("CarsXE %d: %v", res.StatusCode, body["message"]) } // 5xx: exponential backoff if attempt < retries { time.Sleep(time.Duration(1< carsxeRequest(String url, int retries) throws Exception { HttpClient client = HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(10)) .build(); for (int attempt = 0; attempt <= retries; attempt++) { HttpRequest request = HttpRequest.newBuilder(URI.create(url)).GET().build(); HttpResponse res = client.send(request, HttpResponse.BodyHandlers.ofString()); Map body = MAPPER.readValue(res.body(), Map.class); if (Boolean.TRUE.equals(body.get("success"))) { return body; } // 4xx: fix the request (or your quota) — retrying won't help if (res.statusCode() < 500) { throw new RuntimeException("CarsXE " + res.statusCode() + ": " + body.get("message")); } // 5xx: exponential backoff if (attempt < retries) { Thread.sleep((long) Math.pow(2, attempt) * 1000); } } throw new RuntimeException("CarsXE request failed after retries"); } } ``` ```swift import Foundation func carsxeRequest(url: URL, retries: Int = 3) async throws -> [String: Any] { for attempt in 0...retries { let (data, response) = try await URLSession.shared.data(from: url) guard let http = response as? HTTPURLResponse else { throw URLError(.badServerResponse) } let body = try JSONSerialization.jsonObject(with: data) as? [String: Any] ?? [:] if body["success"] as? Bool == true { return body } // 4xx: fix the request (or your quota) — retrying won't help if http.statusCode < 500 { let message = body["message"] as? String ?? "Unknown error" throw NSError(domain: "CarsXE", code: http.statusCode, userInfo: [NSLocalizedDescriptionKey: "CarsXE \(http.statusCode): \(message)"]) } // 5xx: exponential backoff if attempt < retries { try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(attempt))) * 1_000_000_000) } } throw NSError(domain: "CarsXE", code: -1, userInfo: [NSLocalizedDescriptionKey: "CarsXE request failed after retries"]) } ``` ```csharp using System; using System.Net.Http; using System.Text.Json; using System.Threading.Tasks; class Program { static async Task CarsxeRequest(string url, int retries = 3) { using var client = new HttpClient(); for (int attempt = 0; attempt <= retries; attempt++) { var res = await client.GetAsync(url); var body = await res.Content.ReadAsStringAsync(); using var doc = JsonDocument.Parse(body); var root = doc.RootElement; if (root.GetProperty("success").GetBoolean()) { return JsonDocument.Parse(body); } // 4xx: fix the request (or your quota) — retrying won't help if ((int)res.StatusCode < 500) { var message = root.GetProperty("message").GetString(); throw new Exception($"CarsXE {(int)res.StatusCode}: {message}"); } // 5xx: exponential backoff if (attempt < retries) { await Task.Delay((int)Math.Pow(2, attempt) * 1000); } } throw new Exception("CarsXE request failed after retries"); } } ``` --- ## CORS errors The CarsXE API is meant to be called **from your server**, never from the browser. This protects your API key from being stolen — any key shipped to a browser is public. If you call the API from frontend JavaScript, the browser will block the request with a CORS error. Route requests through your backend instead, and keep your key in an environment variable. --- ## Still stuck? If you've checked the tables above and the error doesn't make sense, contact support and include: - The **endpoint** and **parameters** you sent (redact your API key) - The **full response body** and **HTTP status code** - The **timestamp** (with timezone) of the failing request --- # Industry Guides > Explore industry-specific implementation guides for parking, dealerships, insurance, and more. Source: https://carsxe.com/docs/industry-guides ## Available Guides ### Parking & Valet Services Learn how parking companies and applications can leverage CarsXE APIs to provide smart parking solutions based on vehicle dimensions, EV capabilities, and weight restrictions. [View Parking Guide](https://carsxe.com/docs/industry-guides/car-parking-and-valet) --- ## Coming Soon We're working on additional industry guides including: - **Car Dealerships** - VIN decoding, specifications, and history for inventory management - **Insurance Companies** - Risk assessment, claims processing, and underwriting - **Fleet Management** - Vehicle tracking, maintenance scheduling, and compliance - **Car Rental Services** - Vehicle classification, pricing optimization, and damage assessment - **Auto Repair Shops** - Parts lookup, service history, and recall information - **Vehicle Marketplaces** - Listing enrichment, fraud detection, and buyer confidence --- ## Request a Guide Is your industry not listed? We'd love to help! Contact us at [support@carsxe.com](mailto:support@carsxe.com) to request an industry-specific guide. --- # CarsXE for Parking Applications > Learn how parking companies and applications can leverage CarsXE APIs to provide smart parking solutions based on vehicle dimensions, EV capabilities, and other key specifications. Source: https://carsxe.com/docs/industry-guides/car-parking-and-valet Parking applications face a unique challenge: matching vehicles with suitable parking spaces. Whether it's ensuring a large truck can fit in a garage, directing EV owners to charging-enabled spots, or filtering results based on vehicle height restrictions, having accurate vehicle data is essential. CarsXE provides two powerful APIs that parking companies can use to deliver intelligent, personalized parking experiences: 1. **Vehicle Plate Decoder API** - Get vehicle information from license plates 2. **Vehicle Specifications API** - Get detailed specifications from VINs --- ## Common Use Cases ### 1. Size-Based Parking Recommendations **Challenge**: A truck owner in NYC needs to find parking spots that can accommodate their vehicle's dimensions. **Solution**: Use CarsXE to automatically determine vehicle dimensions and filter parking options accordingly. { return spot.maxLength >= parseDimension(dimensions.length) && spot.maxWidth >= parseDimension(dimensions.width) && spot.maxHeight >= parseDimension(dimensions.height); }); ` }} /> **Key Vehicle Attributes**: - `overall_length` - Total vehicle length - `overall_width` - Total vehicle width - `overall_height` - Total vehicle height - `wheelbase_length` - Distance between front and rear axles - `turning_diameter` - Turning radius for tight spaces --- ### 2. EV Charging Station Prioritization **Challenge**: Show EV charging availability prominently to electric vehicle owners. **Solution**: Detect if a vehicle is electric and highlight charging-enabled parking locations. **Fuel Types to Check**: - `Electric` - Fully electric vehicles - `Plug-in Hybrid` - PHEVs requiring charging - `Gasoline` - Traditional gas vehicles - `Diesel` - Diesel vehicles - `Hybrid` - Non-plug-in hybrids --- ### 3. Vehicle Type Classification **Challenge**: Different parking rates and restrictions for motorcycles, compact cars, SUVs, and commercial vehicles. **Solution**: Automatically classify vehicles and apply appropriate pricing/restrictions. **Vehicle Classification Attributes**: - `type` - General vehicle type (Sedan, SUV, Pickup, Motorcycle, etc.) - `style` - Body style (SEDAN 4-DR, COUPE 2-DR, etc.) - `category` - Vehicle category - `vehicle_class` - Weight class (1=Light, 2=Medium, 3=Heavy) - `size` - Size classification --- ### 4. Weight Restrictions **Challenge**: Parking garages often have weight limits for structural safety. **Solution**: Check vehicle weight against garage capacity. garageMaxWeight) { // Show warning or exclude location return { suitable: false, reason: \`Vehicle weight (\${curbWeight} lbs) exceeds garage limit (\${garageMaxWeight} lbs)\` }; } ` }} /> --- ## Implementation Guide ### Step 1: Capture Vehicle Information Parking apps can capture vehicle data in several ways: **Option A: License Plate Entry** **Option B: VIN Entry** **Option C: User Profile** --- ### Step 2: Extract Key Data Points Based on your parking application's needs, extract relevant attributes: --- ### Step 3: Filter & Personalize Results Use the extracted data to customize the parking experience: { // Check dimensions if (spot.maxHeight && parseDimension(vehicleData.height) > spot.maxHeight) { return false; } if (spot.maxLength && parseDimension(vehicleData.length) > spot.maxLength) { return false; } // Check weight if (spot.maxWeight && parseDimension(vehicleData.weight) > spot.maxWeight) { return false; } return true; }).map(spot => { // Add relevance score spot.relevanceScore = 0; // Boost EV charging spots for EV owners if (vehicleData.isEV && spot.hasEVCharging) { spot.relevanceScore += 10; spot.badges = spot.badges || []; spot.badges.push("EV Charging Available"); } // Boost oversized spots for large vehicles if (parseDimension(vehicleData.length) > 200 && spot.oversized) { spot.relevanceScore += 5; } return spot; }).sort((a, b) => b.relevanceScore - a.relevanceScore); } ` }} /> --- ## API Reference Quick Guide ### Vehicle Plate Decoder API **Endpoint**: `GET https://api.carsxe.com/platedecoderr` **Required Parameters**: - `key` - Your CarsXE API key - `plate` - License plate number - `state` - Two-letter state code (for US, CA, AU) - `country` - Two-letter country code (optional for US) **Example Request**: **Key Response Fields**: - `vin` - Vehicle Identification Number (use for detailed specs) - `make` - Vehicle manufacturer - `model` - Vehicle model - `year` / `registration_year` - Model/registration year - `description` - Full vehicle description --- ### Vehicle Specifications API **Endpoint**: `GET https://api.carsxe.com/specs` **Required Parameters**: - `key` - Your CarsXE API key - `vin` - 17-character Vehicle Identification Number **Optional Parameters**: - `format` - Response format (`json` or `xml`) - `deepdata` - Set to `1` for additional data (slower response) **Example Request**: **Key Response Fields for Parking Apps**: | Attribute | Description | Example | |-----------|-------------|---------| | `overall_length` | Total vehicle length | "193.10 in." | | `overall_width` | Total vehicle width | "73.20 in." | | `overall_height` | Total vehicle height | "57.60 in." | | `curb_weight` | Vehicle weight without cargo | "4090 lbs" | | `fuel_type` | Type of fuel/power | "Electric", "Gasoline" | | `type` | Vehicle type | "Sedan/Saloon", "SUV" | | `style` | Body style | "SEDAN 4-DR" | | `turning_diameter` | Turning circle | "37.50 in." | | `wheelbase_length` | Wheelbase length | "116.90 in." | --- ## Best Practices ### 1. Cache Vehicle Data Store vehicle information in user profiles to avoid repeated API calls: new Date()) { // Use cached data return cachedVehicle.specs; } else { // Refresh from API return await carsxe.specs({ vin: userVIN }); } ` }} /> ### 2. Handle Missing Data Gracefully Not all vehicles will have complete specification data: spot.maxHeight) { return { suitable: false }; } return { suitable: true }; } ` }} /> ### 3. Provide Visual Indicators Help users understand why certain spots are recommended: 200 && spot.oversized) { badges.push({ icon: "🚛", text: "Oversized Friendly", type: "info" }); } if (spot.maxHeight > parseDimension(vehicleData.height) + 12) { badges.push({ icon: "📏", text: "Plenty of Clearance", type: "success" }); } return badges; } ` }} /> ### 4. Error Handling --- ## International Support The Plate Decoder API supports license plates from 50+ countries across 6 continents. This enables global parking applications to serve diverse markets: **North America**: US, Canada, Mexico, Costa Rica **Europe**: UK, Germany, France, Spain, Italy, Netherlands, and 25+ more **Asia**: India, China, Singapore, Malaysia, UAE, and more **Oceania**: Australia, New Zealand **South America**: Brazil, Argentina, Chile, Colombia, and more **Africa**: South Africa, Nigeria, Tunisia See the [full country list](https://carsxe.com/docs/v2/plate-decoder#international-support) in the Plate Decoder API documentation. --- ## Pricing & Sandbox **Free Sandbox**: The Vehicle Specifications API is included in the free Sandbox as part of the shared lifetime quota (up to 100 API calls), allowing you to test integration before committing. **Plate Decoder API**: Included in the free Sandbox as part of the shared lifetime quota (up to 100 API calls). Visit our [pricing page](https://carsxe.com/pricing) for details. **Production Use**: Contact sales for volume pricing and enterprise plans tailored to parking applications. --- ## Next Steps 1. [Sign up for a free API key](https://carsxe.com/signin) 2. Review the [Plate Decoder API documentation](https://carsxe.com/docs/v2/plate-decoder) 3. Review the [Specifications API documentation](https://carsxe.com/docs/v1/specifications) 4. Test the integration in your development environment 5. Contact [support@carsxe.com](mailto:support@carsxe.com) for integration assistance --- ## Example: Complete Parking Search Flow Here's a complete example showing how a parking app might implement vehicle-aware search: { return isVehicleSuitable(vehicleData, spot); }); // Step 3: Rank by relevance const rankedSpots = filteredSpots.map(spot => ({ ...spot, relevance: calculateRelevance(vehicleData, spot), badges: generateBadges(vehicleData, spot) })).sort((a, b) => b.relevance - a.relevance); return { vehicleData, results: rankedSpots, filteredCount: parkingLocations.length - filteredSpots.length }; } function extractParkingData(attributes) { return { length: parseFloat(attributes.overall_length) || null, width: parseFloat(attributes.overall_width) || null, height: parseFloat(attributes.overall_height) || null, weight: parseFloat(attributes.curb_weight) || null, isEV: attributes.fuel_type === "Electric", isPHEV: attributes.fuel_type === "Plug-in Hybrid", type: attributes.type, make: attributes.make, model: attributes.model, year: attributes.year }; } function isVehicleSuitable(vehicle, spot) { if (!vehicle) return true; // No vehicle data, show all if (spot.maxHeight && vehicle.height && vehicle.height > spot.maxHeight) { return false; } if (spot.maxLength && vehicle.length && vehicle.length > spot.maxLength) { return false; } if (spot.maxWeight && vehicle.weight && vehicle.weight > spot.maxWeight) { return false; } return true; } function calculateRelevance(vehicle, spot) { let score = 0; // EV charging match if ((vehicle.isEV || vehicle.isPHEV) && spot.hasEVCharging) { score += 20; } // Comfortable fit (not too tight) if (vehicle.height && spot.maxHeight) { const clearance = spot.maxHeight - vehicle.height; if (clearance > 12) score += 10; // 1 foot+ clearance } // Covered parking bonus for all if (spot.covered) score += 5; // Security features if (spot.security24_7) score += 5; return score; } function generateBadges(vehicle, spot) { const badges = []; if ((vehicle.isEV || vehicle.isPHEV) && spot.hasEVCharging) { badges.push({ text: "EV Charging", icon: "⚡", variant: "success" }); } if (vehicle.length > 200 && spot.oversized) { badges.push({ text: "Large Vehicle OK", icon: "🚛", variant: "info" }); } return badges; } // Usage const results = await searchParking( { plate: "7XER187", state: "CA" }, allParkingLocations ); ` }} /> --- ## Support Have questions about integrating CarsXE into your parking application? - **Documentation**: [docs.carsxe.com](https://carsxe.com/docs) - **Email**: [support@carsxe.com](mailto:support@carsxe.com) - **API Status**: [status.carsxe.com](https://status.carsxe.com) We're here to help you build better parking experiences! --- # Integrations > Explore our official SDKs and third-party integrations to accelerate your development with the CarsXE API. Source: https://carsxe.com/docs/integrations Integrate the CarsXE API into your applications with our official libraries and tools. These resources simplify the process of making API calls and handling responses, allowing you to focus on building your product. ## Official SDKs

### Go

Official Go SDK for integrating CarsXE API into your Go applications.

### Java

Official Java SDK for integrating CarsXE API into your Java applications.

### .NET

Official .NET SDK for integrating CarsXE API into your .NET, C#, and ASP.NET applications with full async/await support.

### Node.js

Use our official Node.js library to integrate CarsXE into your JavaScript or TypeScript projects.

### PHP

Official PHP SDK for integrating CarsXE API into your PHP applications.

### Python

The official Python package for accessing the CarsXE API from your Python application.

### Ruby

Official Ruby gem for integrating CarsXE API into your Ruby and Rails applications.

### Swift

Official Swift Package for integrating CarsXE API into your iOS, macOS, and server-side Swift applications.

## Developer Tools

### CLI

Query vehicle specs, market value, history, recalls, plates, and OBD codes directly from your terminal.

## AI & Automation Integrations

### MCP Integration

AI-powered vehicle data integration for Claude, Cursor, and other MCP-compatible tools.

### Claude Code Plugin

Access CarsXE vehicle data APIs directly from Claude Code with simple commands and auto-invoked skills.

### Codex Plugin

Access CarsXE vehicle data APIs directly from OpenAI Codex with auto-invoked skills — no slash commands to memorize.

### Gemini CLI Extension

Access CarsXE vehicle data APIs directly from Gemini CLI with simple commands and auto-invoked skills.

### Google ADK

Connect the CarsXE MCP server to your Google Agent Development Kit (ADK) agents — VIN and plate decoding, market values, history, recalls, images, and OBD codes over a single remote endpoint.

### OpenClaw Skill

Extend your OpenClaw AI agent with CarsXE vehicle data — VIN decoding, plate lookup, market values, history, and more.

## Data Tools

### Snowflake

Access comprehensive vehicle data directly in Snowflake via the CarsXE Native App, with Streamlit UI and SQL-callable procedures for seamless integration.

## No-Code Integrations

### n8n

Automate vehicle data workflows in n8n with the official CarsXE node — VIN decoding, plate lookup, history reports, market values, and more.

### Zapier

Connect CarsXE with thousands of other apps and automate your workflows with no code using our Zapier integration.

### Make

Build powerful automations and connect CarsXE with your favorite apps using Make's visual no-code platform.

--- # Google ADK Integration > Connect the CarsXE MCP server to your Google Agent Development Kit (ADK) agents — decode VINs and plates, get market values, history, recalls, liens, images, and OBD codes with natural language. Source: https://carsxe.com/docs/integrations/adk-quickstart ## What is the CarsXE Integration for Google ADK? The CarsXE MCP server brings the full suite of CarsXE vehicle data APIs into your [Google Agent Development Kit (ADK)](https://google.github.io/adk-docs/) agents through a single remote endpoint at `https://mcp.carsxe.com/mcp`. Your agents can decode VINs and license plates, retrieve market values and ownership history, check safety recalls, and diagnose trouble codes — all from natural language queries, with no local install. **ADK Integration Page**: [adk.dev/integrations/carsxe](https://adk.dev/integrations/carsxe/) **MCP Endpoint**: `https://mcp.carsxe.com/mcp` ## Key Use Cases - **Vehicle identification** — turn VINs or license plates into structured data: make, model, year, engine, trim, and equipment specifications. - **Vehicle assessment** — market valuations, ownership histories, and active safety recall information to inform purchasing and servicing decisions. - **Diagnostic support** — convert OBD-II trouble codes (like `P0300`) into readable definitions and probable causes. - **Image processing** — extract vehicle identifiers from photos and retrieve visual media by make and model. ## Prerequisites Before you begin, ensure you have: 1. An installed [ADK environment](https://google.github.io/adk-docs/get-started/) 2. A CarsXE API key — get one from the [CarsXE developer dashboard](https://carsxe.com/dashboard/developer) ## Installation The integration connects to the hosted CarsXE MCP server over streamable HTTP — there is nothing to install locally. Add the `McpToolset` to your agent and pass your CarsXE API key via the `X-API-Key` header. ### Python ```python from google.adk.agents import Agent from google.adk.tools.mcp_tool import McpToolset from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams CARSXE_API_KEY = "YOUR_CARSXE_API_KEY" root_agent = Agent( model="gemini-flash-latest", name="carsxe_agent", instruction="You are a vehicle data assistant...", tools=[ McpToolset( connection_params=StreamableHTTPConnectionParams( url="https://mcp.carsxe.com/mcp", headers={"X-API-Key": CARSXE_API_KEY}, ), ) ], ) ``` ### TypeScript ```typescript import { LlmAgent, MCPToolset } from "@google/adk"; const CARSXE_API_KEY = "YOUR_CARSXE_API_KEY"; const rootAgent = new LlmAgent({ model: "gemini-flash-latest", name: "carsxe_agent", instruction: "You are a vehicle data assistant...", tools: [ new MCPToolset({ type: "StreamableHTTPConnectionParams", url: "https://mcp.carsxe.com/mcp", transportOptions: { requestInit: { headers: { "X-API-Key": CARSXE_API_KEY }, }, }, }), ], }); ``` ## Available Tools | Tool | Function | |------|----------| | `get-vehicle-specs` | Decode a VIN to full specifications | | `decode-vehicle-plate` | Extract vehicle data from a license plate | | `get-market-value` | Determine current vehicle valuation | | `get-vehicle-history` | Access ownership and accident records | | `get-vehicle-recalls` | Check active safety recalls | | `get-lien-theft` | Verify lien and theft status | | `international-vin-decoder` | Decode non-US VINs | | `vin-ocr` | Extract a VIN from an image | | `recognize-plate-image` | Identify a plate in a photo | | `get-year-make-model` | Retrieve specs by vehicle attributes | | `get-vehicle-images` | Fetch images by make and model | | `decode-obd-code` | Translate OBD-II trouble codes | ## Authentication The integration uses header-based authentication. Send your CarsXE API key in the `X-API-Key` header on every request to the hosted MCP server over a streamable HTTP connection — no local installation required. If you do not have a key yet, sign up and get one from the [CarsXE developer dashboard](https://carsxe.com/dashboard/developer). ## Usage Examples Once the toolset is attached, your ADK agent invokes CarsXE tools automatically when it detects relevant context. For example: - *"What can you tell me about VIN WBAFR7C57CC811956?"* — calls `get-vehicle-specs` - *"Does this car have any open recalls? VIN: WBAFR7C57CC811956"* — calls `get-vehicle-recalls` - *"My check engine light is on with code P0300"* — calls `decode-obd-code` - *"How much is a 2012 BMW X5 worth?"* — calls `get-market-value` ## API Documentation Full API documentation is available at [carsxe.com/docs](https://carsxe.com/docs). --- # Claude Code Plugin > Access the full suite of CarsXE vehicle data APIs directly from Claude Code — decode VINs, look up license plates, get market values, check history, recalls, liens, OBD codes, and more. Source: https://carsxe.com/docs/integrations/claude-quickstart ## What is the CarsXE Plugin for Claude Code? The CarsXE Plugin for Claude Code provides direct access to our comprehensive automotive APIs through simple commands and auto-invoked skills. Decode VINs, look up license plates, get market values, check vehicle history, recalls, liens, OBD codes, and more — all within your Claude Code environment. **GitHub Repository**: [carsxe-claude-plugin](https://github.com/carsxe/carsxe-claude-plugin) ## Plugin Marketplaces You can also find and install the CarsXE plugin from these Claude plugin directories: - [Claude Plugin Hub](https://www.claudepluginhub.com/plugins/carsxe-carsxe-carsxe) - [Build With Claude](https://buildwithclaude.com/plugins?q=CarsXE) ## Installation ### Step 1: Add the CarsXE Marketplace ```bash /plugin marketplace add carsxe/carsxe-claude-plugin ``` ### Step 2: Install the Plugin ```bash /plugin install carsxe ``` ## Setup ### 1. Get Your CarsXE API Key 1. Visit the [CarsXE API dashboard](https://carsxe.com/dashboard/developer) 2. Navigate to your API keys section 3. Copy your API key ### 2. Authenticate with Your API Key Use the auth command to validate credentials and establish session access: /carsxe:auth your_api_key_here ## Available Commands | Command | Description | | ------------------------------------------ | ------------------------------------- | | `/carsxe:auth ` | Validate and configure API credentials | | `/carsxe:specs ` | Decode a VIN — full vehicle specs | | `/carsxe:plate [STATE]` | Look up vehicle from license plate | | `/carsxe:value ` | Get current market value | | `/carsxe:history ` | Full vehicle history report | | `/carsxe:images [YEAR]` | Fetch vehicle photos | | `/carsxe:recalls ` | Check for open safety recalls | | `/carsxe:intvin ` | Decode international (non-US) VINs | | `/carsxe:ocr ` | Extract VIN from a photo | | `/carsxe:lien ` | Check for liens and theft records | | `/carsxe:plateocr ` | Extract license plate from a photo | | `/carsxe:ymm [TRIM]` | Look up vehicle by Year/Make/Model | | `/carsxe:obd

`                       | Decode an OBD diagnostic trouble code |

## Usage Examples
### Decode a VIN

/carsxe:specs WBAFR7C57CC811956

### Look up a California Plate

/carsxe:plate 7XER187 US CA

### Check Market Value

/carsxe:value WBAFR7C57CC811956

### Get Vehicle History

/carsxe:history WBAFR7C57CC811956

### Find Vehicle Images

/carsxe:images BMW X5 2019

### Check Recalls

/carsxe:recalls WBAFR7C57CC811956

### Decode an International VIN

/carsxe:intvin WF0MXXGBWM8R43240

### Extract VIN from a Photo

/carsxe:ocr https://example.com/vin-photo.jpg

### Check Liens and Theft

/carsxe:lien WBAFR7C57CC811956

### Extract Plate from a Photo

/carsxe:plateocr https://example.com/plate-photo.jpg

### Look up by Year/Make/Model

/carsxe:ymm 2020 Toyota Camry LE

### Decode an OBD Code

/carsxe:obd P0300

## Skills (Auto-invoked)

Skills are automatically triggered by Claude based on the conversation context. No need to type a command — just describe what you need naturally.

| Natural Language Query                         | Triggered Skill   |
| ---------------------------------------------- | ----------------- |
| "What are the specs of VIN WBAFR7C57CC811956?" | `vehicle-specs`   |
| "Does this car have any recalls?"              | `vehicle-recalls` |
| "What does the check engine code P0300 mean?"  | `obd-decoder`     |
| "What's the value of this vehicle?"            | `market-value`    |
| "Show me images of a 2020 Tesla Model 3"       | `vehicle-images`  |
| "Get the history report for this VIN"          | `vehicle-history` |

## Troubleshooting

### Common Issues

**Authentication Error**

- Verify your API key is correct
- Ensure the `CARSXE_API_KEY` environment variable is set
- Check that your API key has the necessary permissions

**Plugin Not Found**

- Verify you've added the marketplace correctly
- Try reinstalling the plugin
- Restart Claude Code

**Command Not Working**

- Check the command syntax matches the examples above
- Ensure all required parameters are provided
- Verify your API account has sufficient credits

Ready to supercharge your vehicle data workflows with CarsXE and Claude Code!


---

# CLI Quickstart Guide

> Query vehicle specs, market value, history, recalls, license plates, OBD codes, and more — directly from your terminal using the CarsXE CLI.

Source: https://carsxe.com/docs/integrations/cli-quickstart



  


The CarsXE CLI lets you query vehicle data straight from your terminal — no browser, no code, no boilerplate. It works on Linux, macOS, and Windows, and is designed to integrate naturally with shell scripts, AI agents, and developer workflows.


  You will need a CarsXE API key before using the CLI. Grab one from your [Dashboard → Developer](https://carsxe.com/dashboard/developer) page.


## Requirements

- **Node.js 22 or higher** — [nodejs.org](https://nodejs.org)

## Installation

Install the CLI globally with npm:



```bash
npm install -g @carsxe/cli
```



Verify the installation:



```bash
carsxe --version
```



## Setup

Save your API key once — it is stored locally and used automatically for every command:



```bash
carsxe config set-key YOUR_API_KEY
```



The key is saved to a local config file:

| OS | Path |
| --- | --- |
| Linux / macOS | `~/.carsxe/config.json` |
| Windows | `C:\Users\\.carsxe\config.json` |

### Using an environment variable instead

If you prefer not to save the key to disk, set the `CARSXE_API_KEY` environment variable. The environment variable takes precedence over the saved config file.



```bash
export CARSXE_API_KEY=YOUR_API_KEY
```





```bash
$env:CARSXE_API_KEY = "YOUR_API_KEY"
```





```bash
set CARSXE_API_KEY=YOUR_API_KEY
```



To make the variable permanent on Linux/macOS, add the `export` line to your `~/.bashrc`, `~/.zshrc`, or `~/.profile`.

---

## Global Options

These options apply to every command:

| Option | Description |
| --- | --- |
| `--table` | Output as a formatted table instead of JSON |
| `--raw` | Output compact single-line JSON (useful with `jq`) |
| `-v, --version` | Print the version number |
| `-h, --help` | Display help |

Run `carsxe  --help` to see all options for any specific command.

---

## Commands

### `specs` — Vehicle Specifications

Decode a VIN and get full vehicle specifications: make, model, year, engine, trim, equipment, and more.



```bash
carsxe specs --vin 1HGBH41JXMN109186
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |
| `--deep-data` | No | Enable deep data (additional equipment details) |
| `--disable-int-vin` | No | Disable international VIN decoding fallback |

---

### `market-value` — Market Value

Get the current estimated market value of a vehicle.



```bash
carsxe market-value --vin 1HGBH41JXMN109186 --mileage 45000 --state CA --condition clean
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |
| `--mileage ` | No | Current odometer reading in miles |
| `--state ` | No | Two-letter US state code for regional pricing (e.g. `CA`, `TX`) |
| `--condition ` | No | Vehicle condition: `excellent` \| `clean` \| `average` \| `rough` |
| `--country ` | No | Country code for pricing (default: `US`) |

---

### `history` — Vehicle History

Get a full vehicle history report including past owners, accidents, title status, and odometer readings.



```bash
carsxe history --vin 1HGBH41JXMN109186
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |

---

### `recalls` — Safety Recalls

Check for open safety recalls on a vehicle.



```bash
carsxe recalls --vin 1HGBH41JXMN109186
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |

---

### `lien-theft` — Lien & Theft Check

Check whether a vehicle has active liens or has been reported stolen.



```bash
carsxe lien-theft --vin 1HGBH41JXMN109186
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |

---

### `international-vin` — International VIN Decoder

Decode a VIN from a non-US vehicle (European, Asian, and other markets).



```bash
carsxe international-vin --vin WBAFR7C57CC811956
```



| Option | Required | Description |
| --- | --- | --- |
| `--vin ` | Yes | Vehicle Identification Number |

---

### `plate-decoder` — License Plate Decoder

Look up vehicle information from a license plate number.



```bash
carsxe plate-decoder --plate ABC1234 --country US --state CA
```



| Option | Required | Description |
| --- | --- | --- |
| `--plate ` | Yes | License plate number |
| `--country ` | Yes | Country code (e.g. `US`, `GB`, `DE`, `CA`) |
| `--state ` | No | State or province code (e.g. `CA`, `TX`, `ON`) |
| `--district ` | No | District or region |

---

### `plate-image` — Plate Image Recognition

Extract and decode a license plate from an image URL.



```bash
carsxe plate-image --image https://example.com/car-photo.jpg
```



| Option | Required | Description |
| --- | --- | --- |
| `--image ` | Yes | Publicly accessible URL of the image |

---

### `vin-ocr` — VIN OCR from Image

Extract a VIN from a photo of a VIN plate or dashboard sticker.



```bash
carsxe vin-ocr --image https://example.com/vin-sticker.jpg
```



| Option | Required | Description |
| --- | --- | --- |
| `--image ` | Yes | Publicly accessible URL of the image |

---

### `ymm` — Year / Make / Model

Look up vehicle data when you don't have a VIN — search by year, make, and model instead.



```bash
carsxe ymm --year 2020 --make Toyota --model Camry --trim LE
```



| Option | Required | Description |
| --- | --- | --- |
| `--year ` | Yes | Model year (e.g. `2020`) |
| `--make ` | Yes | Vehicle make (e.g. `Toyota`) |
| `--model ` | Yes | Vehicle model (e.g. `Camry`) |
| `--trim ` | No | Trim level (e.g. `LE`, `XSE`) |

---

### `images` — Vehicle Images

Retrieve photos of a vehicle by make, model, and year.



```bash
carsxe images --make Toyota --model Camry --year 2020 --angle front --size Large
```



| Option | Required | Description |
| --- | --- | --- |
| `--make ` | Yes | Vehicle make |
| `--model ` | Yes | Vehicle model |
| `--year ` | No | Model year |
| `--trim ` | No | Trim level |
| `--color ` | No | Vehicle color |
| `--angle ` | No | Photo angle: `front` \| `side` \| `back` |
| `--photo-type ` | No | Photo type: `interior` \| `exterior` \| `engine` |
| `--size ` | No | Image size: `Small` \| `Medium` \| `Large` \| `Wallpaper` \| `All` |

---

### `obd` — OBD-II Code Decoder

Decode a diagnostic trouble code (DTC) from your OBD-II scanner.



```bash
carsxe obd --code P0300
```



| Option | Required | Description |
| --- | --- | --- |
| `--code ` | Yes | OBD-II code (e.g. `P0300`, `C1234`, `B0001`, `U0100`) |

---

### `config` — Configuration

Manage your saved API key.



```bash
# Save your API key
carsxe config set-key YOUR_API_KEY
# Show active key and its source
carsxe config get-key
# Remove the saved key
carsxe config remove-key
```



---

## Output Formats

By default all commands return pretty-printed JSON. Two flags change the format:

**Table view** — human-friendly two-column layout, great for quick inspection:



```bash
carsxe --table obd --code P0300
```



Nested objects are flattened with dot notation (e.g. `engine.cylinders`). Arrays of primitives are joined on a single line.

**Raw JSON** — compact single-line output:



```bash
carsxe --raw specs --vin 1HGBH41JXMN109186
```



---

## What's next?

- [Grab your API key from the CarsXE dashboard](https://carsxe.com/dashboard/developer)
- [Browse the full Vehicle Specifications API](https://carsxe.com/docs/v1/specifications)
- [Learn about authentication](https://carsxe.com/docs/authentication)
- [Check the full list of error codes](https://carsxe.com/docs/errors)


---

# Codex Plugin

> Access the full suite of CarsXE vehicle data APIs directly from OpenAI Codex — decode VINs, look up license plates, get market values, check history, recalls, liens, OBD codes, and more.

Source: https://carsxe.com/docs/integrations/codex-quickstart


## What is the CarsXE Plugin for OpenAI Codex?

The CarsXE Plugin for OpenAI Codex provides direct access to our comprehensive automotive APIs through auto-invoked skills. Codex picks the right skill based on what you ask — no slash commands to memorize, just describe what you need. Decode VINs, look up license plates, get market values, check vehicle history, recalls, liens, OBD codes, and more — all within your Codex environment.

**GitHub Repository**: [carsxe-codex-plugin](https://github.com/carsxe/carsxe-codex-plugin)

**Plugin Registry**: [hol.org/registry/plugins/carsxe/carsxe](https://hol.org/registry/plugins/carsxe%2Fcarsxe)

## Installation

Install from the Codex Plugin Marketplace:


```bash 
npx codex-marketplace add carsxe/carsxe-codex-plugin --plugin --project 
```


Or browse and install interactively from within Codex:


```bash 
/plugins 
```


## Setup

### 1. Get Your CarsXE API Key

1. Visit the [CarsXE API dashboard](https://carsxe.com/dashboard/developer)
2. Navigate to your API keys section
3. Copy your API key

### 2. Set the `CARSXE_API_KEY` Environment Variable

Codex skills read your key from `CARSXE_API_KEY`. Set it before launching Codex:


```bash 
export CARSXE_API_KEY="cxe_live_YOUR_KEY" 
```



```powershell 
$env:CARSXE_API_KEY="cxe_live_YOUR_KEY" 
```


Add it to your shell profile to persist it across sessions.

## Skills (Auto-invoked)

Skills are automatically triggered by Codex based on the conversation context. No need to type a command — just describe what you need naturally. You can also call a skill explicitly by name with the `@` prefix, e.g. `@vehicle-specs`.

| Skill                     | What it does                                |
| ------------------------- | -------------------------------------------- |
| `vehicle-specs`           | Decode a VIN — full vehicle specifications   |
| `plate-decoder`           | Look up a vehicle from a license plate       |
| `market-value`            | Estimate a vehicle's current market value    |
| `vehicle-history`         | Full vehicle history report                  |
| `vehicle-images`          | Fetch vehicle photos by make/model/year       |
| `vehicle-recalls`         | Check for open safety recalls                |
| `international-vin`       | Decode international (non-US) VINs           |
| `vin-ocr`                 | Extract a VIN from a photo                   |
| `lien-theft`              | Check for liens and theft records            |
| `plate-image-recognition` | Extract a license plate number from a photo  |
| `year-make-model`         | Look up a vehicle by Year/Make/Model         |
| `obd-decoder`             | Decode an OBD-II diagnostic trouble code     |

## Usage Examples

Just ask Codex naturally — the matching skill is invoked automatically:

### Decode a VIN

Decode VIN WBAFR7C57CC811956

### Look up a California Plate

Look up California plate 7XER187

### Check Market Value

What's this car worth? VIN WBAFR7C57CC811956, 45k miles, clean condition

### Get Vehicle History

Get the history report for WBAFR7C57CC811956

### Check Recalls

Does 1C4JJXR64PW696340 have any open recalls?

### Check Liens and Theft

Is this VIN stolen or have a lien? WBAFR7C57CC811956

### Decode an International VIN

Decode this international VIN: WF0MXXGBWM8R43240

### Look up by Year/Make/Model

Look up a 2020 Toyota Camry LE

### Decode an OBD Code

What does check engine code P0300 mean?

### Extract VIN from a Photo

Extract the VIN from this photo: https://example.com/vin.jpg

### Extract Plate from a Photo

Read the plate in this image: https://example.com/plate.jpg

### Find Vehicle Images

Show me photos of a 2019 BMW X5

## Troubleshooting

### Common Issues

**Authentication Error**

- Verify your API key is correct
- Ensure the `CARSXE_API_KEY` environment variable is set
- Check that your API key has the necessary permissions

**Plugin Not Found**

- Verify you installed via `npx codex-marketplace add carsxe/carsxe-codex-plugin --plugin --project`
- Try reinstalling the plugin via `/plugins`
- Restart Codex

**Skill Not Triggering**

- Try calling the skill explicitly with the `@` prefix, e.g. `@vehicle-specs`
- Ensure all required parameters (VIN, plate, etc.) are included in your prompt
- Verify your API account has sufficient credits

Ready to supercharge your vehicle data workflows with CarsXE and OpenAI Codex!


---

# .NET Quickstart Guide

> Get started with CarsXE's .NET SDK to integrate comprehensive vehicle data into your .NET applications.

Source: https://carsxe.com/docs/integrations/dotnet-quickstart


The CarsXE .NET SDK provides a simple and powerful way to integrate vehicle data into your .NET applications. This guide will help you get started quickly.

For more information, see the package on NuGet.

## Installation

Install the CarsXE .NET package using NuGet:

`dotnet add package CarsXE`

## Setup

First, import the CarsXE client and initialize it with your API key:


```csharp
using carsxe;
string API_KEY = "YOUR_API_KEY";
CarsXE carsxe = new CarsXE(API_KEY);
```


## Basic Usage

### VIN Specifications


```csharp
string vin = "WBAFR7C57CC811956";
try
{
    var specs = carsxe.Specs(new Dictionary { { "vin", vin } }).Result;
    Console.WriteLine("API Response:");
    Console.WriteLine(specs.RootElement.GetProperty("input").GetProperty("vin").ToString());
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### International VIN Decoder


```csharp
try
{
    var intvin = carsxe.InternationalVinDecoder(new Dictionary
    {
        { "vin", "WF0MXXGBWM8R43240" }
    }).Result;
    Console.WriteLine(intvin);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Market Value


```csharp
try
{
    var marketvalue = carsxe.MarketValue(new Dictionary
    {
        { "vin", "WBAFR7C57CC811956" }
    }).Result;
    Console.WriteLine(marketvalue);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Vehicle History


```csharp
try
{
    var history = carsxe.History(new Dictionary
    {
        { "vin", "WBAFR7C57CC811956" }
    }).Result;
    Console.WriteLine(history);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### License Plate Decoder


```csharp
try
{
    var decodedPlate = carsxe.PlateDecoder(new Dictionary
    {
        { "plate", "7XER187" },
        { "state", "CA" },
        { "country", "US" }
    }).Result;
    Console.WriteLine(decodedPlate);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Vehicle Images


```csharp
try
{
    var images = carsxe.Images(new Dictionary
    {
        { "make", "BMW" },
        { "model", "X5" },
        { "year", "2019" }
    }).Result;
    Console.WriteLine(images);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Vehicle Recalls


```csharp
try
{
    var recalls = carsxe.Recalls(new Dictionary
    {
        { "vin", "1C4JJXR64PW696340" }
    }).Result;
    Console.WriteLine(recalls);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Plate Image Recognition


```csharp
try
{
    var plateimg = carsxe.PlateImageRecognition(
        "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"
    ).Result;
    Console.WriteLine(plateimg);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### VIN OCR from Image


```csharp
try
{
    var vinocr = carsxe.VinOcr(
        "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"
    ).Result;
    Console.WriteLine(vinocr);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Year-Make-Model Search


```csharp
try
{
    var yymm = carsxe.YearMakeModel(new Dictionary
    {
        { "year", "2012" },
        { "make", "BMW" },
        { "model", "5 Series" }
    }).Result;
    Console.WriteLine(yymm);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### OBD Code Decoder


```csharp
try
{
    var obdcode = carsxe.ObdCodesDecoder(new Dictionary
    {
        { "code", "P0115" }
    }).Result;
    Console.WriteLine(obdcode);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


### Lien and Theft


```csharp
try
{
    var lienAndTheft = carsxe.LienAndTheft(new Dictionary
    {
        { "vin", "2C3CDXFG1FH762860" }
    }).Result;
    Console.WriteLine(lienAndTheft);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```


Start building powerful automotive applications with CarsXE's .NET SDK!


---

# Gemini CLI Extension

> Access the full suite of CarsXE vehicle data APIs directly from Gemini CLI — decode VINs, look up license plates, get market values, check history, recalls, liens, OBD codes, and more.

Source: https://carsxe.com/docs/integrations/gemini-quickstart


## What is the CarsXE Extension for Gemini CLI?

Access the full suite of CarsXE vehicle data APIs directly from Gemini CLI. Decode VINs, look up license plates, get market values, vehicle history, recalls, lien and theft records, OBD codes, and more.

**GitHub Repository**: [carsxe-gemini-extension](https://github.com/carsxe/carsxe-gemini-extension)

## Features

| Command                                    | Description                                   |
| ------------------------------------------ | --------------------------------------------- |
| `/carsxe:auth `                   | Validate and set your CarsXE API key          |
| `/carsxe:specs `                      | Decode a VIN with full vehicle specifications |
| `/carsxe:plate   [STATE]`  | Look up a vehicle by license plate            |
| `/carsxe:value `                      | Get current market value                      |
| `/carsxe:history `                    | Full vehicle history report                   |
| `/carsxe:images   [YEAR]`     | Retrieve vehicle photos                       |
| `/carsxe:recalls `                    | Check for open safety recalls                 |
| `/carsxe:intvin `                     | Decode an international (non-US) VIN          |
| `/carsxe:ocr `                  | Extract a VIN from a photo (OCR)              |
| `/carsxe:lien `                       | Check for liens and theft records             |
| `/carsxe:plateocr `             | Extract a plate number from a photo           |
| `/carsxe:ymm    [TRIM]` | Look up by Year/Make/Model                    |
| `/carsxe:obd `                       | Decode an OBD-II trouble code                 |

All commands also have corresponding **skills** that Gemini auto-invokes when it detects relevant context in your conversation.

## Prerequisites

Before installing the extension, make sure you have the [Gemini CLI](https://github.com/google-gemini/gemini-cli) installed and your `GEMINI_API_KEY` environment variable set.

You can get a Gemini API key from [Google AI Studio](https://aistudio.google.com/apikey).

**macOS / Linux — add to your shell profile for persistence:**


```bash
echo 'export GEMINI_API_KEY=your_gemini_api_key_here' >> ~/.bashrc
source ~/.bashrc
```


If you use Zsh (default on macOS), replace `~/.bashrc` with `~/.zshrc`.

**Windows — PowerShell (current session):**


```powershell
$env:GEMINI_API_KEY="your_gemini_api_key_here"
```


**Windows — PowerShell (persist across sessions):**


```powershell
[System.Environment]::SetEnvironmentVariable("GEMINI_API_KEY","your_gemini_api_key_here","User")
```


**Windows — Command Prompt:**


```cmd
setx GEMINI_API_KEY "your_gemini_api_key_here"
```


After `setx`, restart your terminal for the variable to take effect.

## Installation

Install the extension from the GitHub repository:


```bash
gemini extensions install https://github.com/carsxe/carsxe-gemini-extension.git
```


During installation, Gemini CLI prompts you for your CarsXE API key. If you do not have a key yet, sign up and get one from the [CarsXE developer dashboard](https://carsxe.com/dashboard/developer).

If you skipped that prompt, or you want to change your API key after installing, run:


```bash
gemini extensions config carsxe
```


This stores your API key securely in the system keychain.

## Usage Examples

### Decode a VIN


```bash
/carsxe:specs WBAFR7C57CC811956
```


### Look up a license plate


```bash
/carsxe:plate 7XER187 US CA
```


### Get market value


```bash
/carsxe:value WBAFR7C57CC811956
```


### Vehicle history report


```bash
/carsxe:history WBAFR7C57CC811956
```


### Vehicle images


```bash
/carsxe:images BMW X5 2019
```


### Check recalls


```bash
/carsxe:recalls WBAFR7C57CC811956
```


### International VIN


```bash
/carsxe:intvin WF0MXXGBWM8R43240
```


### VIN OCR from image


```bash
/carsxe:ocr https://example.com/vin-photo.jpg
```


### Lien and theft check


```bash
/carsxe:lien WBAFR7C57CC811956
```


### Plate recognition from image


```bash
/carsxe:plateocr https://example.com/plate-photo.jpg
```


### Year/Make/Model lookup


```bash
/carsxe:ymm 2020 Toyota Camry LE
```


### OBD code decode


```bash
/carsxe:obd P0300
```


## Skills (Auto-invoked)

Gemini will automatically use the CarsXE tools when it detects relevant queries. For example:

- *"What can you tell me about VIN WBAFR7C57CC811956?"* — triggers the `vehicle-specs` skill
- *"Does this car have any recalls? VIN: WBAFR7C57CC811956"* — triggers the `vehicle-recalls` skill
- *"My check engine light is on with code P0300"* — triggers the `obd-decoder` skill
- *"How much is a 2012 BMW X5 worth? VIN WBAFR7C57CC811956"* — triggers the `market-value` skill

## API Documentation

Full API documentation is available at [carsxe.com/docs](https://carsxe.com/docs).


---

# Go Quickstart Guide

> Get started with CarsXE's Go package to integrate comprehensive vehicle data into your Go applications.

Source: https://carsxe.com/docs/integrations/go-quickstart


The CarsXE Go package provides a simple and powerful way to integrate vehicle data into your Go applications. This guide will help you get started quickly.

For more information, see the package on pkg.go.dev.

## Installation

Install the CarsXE Go package using go get:

`go get -u github.com/carsxe/carsxe-go-package`

## Setup

First, import the CarsXE client and initialize it with your API key:


```go
package main
import (
	"fmt"
	"github.com/carsxe/carsxe-go-package"
)
func main() {
	// Initialize the client
	client := carsxe.New("YOUR_API_KEY_HERE")
}
```


## Basic Usage

### VIN Specifications


```go
vin := "WBAFR7C57CC811956"
vehicle := client.Specs(map[string]string{"vin": vin})
fmt.Println(vehicle["input"].(map[string]interface{})["vin"])
```


### International VIN Decoder


```go
intvin := client.InternationalVINDecoder(map[string]string{
	"vin": "WF0MXXGBWM8R43240",
})
fmt.Println(intvin)
```


### Market Value


```go
marketvalue := client.MarketValue(map[string]string{
	"vin": "WBAFR7C57CC811956",
})
fmt.Println(marketvalue)
```


### Vehicle History


```go
history := client.History(map[string]string{
	"vin": "WBAFR7C57CC811956",
})
fmt.Println(history)
```


### License Plate Decoder


```go
decodedPlate := client.PlateDecoder(map[string]string{
	"plate":   "7XER187",
	"state":   "CA",
	"country": "US",
})
fmt.Println(decodedPlate)
```


### Vehicle Images


```go
images := client.Images(map[string]string{
	"make":  "BMW",
	"model": "X5",
	"year":  "2019",
})
fmt.Println(images)
```


### Vehicle Recalls


```go
recalls := client.Recalls(map[string]string{
	"vin": "1C4JJXR64PW696340",
})
fmt.Println(recalls)
```


### Plate Image Recognition


```go
plateimg := client.PlateImageRecognition(map[string]string{
	"upload_url": "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public",
})
fmt.Println(plateimg)
```


### VIN OCR from Image


```go
vinocr := client.VinOCR(map[string]string{
	"upload_url": "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public",
})
fmt.Println(vinocr)
```


### Year-Make-Model Search


```go
yymm := client.YearMakeModel(map[string]string{
	"year":  "2012",
	"make":  "BMW",
	"model": "5 Series",
})
fmt.Println(yymm)
```


### OBD Code Decoder


```go
obdcode := client.ObdCodesDecoder(map[string]string{
	"code": "P0115",
})
fmt.Println(obdcode)
```


### Lien and Theft


```go
lienAndTheft := client.LienAndTheft(map[string]string{
	"vin": "2C3CDXFG1FH762860",
})
fmt.Println(lienAndTheft)
```


Start building powerful automotive applications with CarsXE's Go package!


---

# Java Quickstart Guide

> Get started with CarsXE's Java SDK to integrate comprehensive vehicle data into your Java applications.

Source: https://carsxe.com/docs/integrations/java-quickstart


The CarsXE Java SDK provides a simple and powerful way to integrate vehicle data into your Java applications. This guide will help you get started quickly.

For more information, see the package on Maven Central.

## Installation

### Maven

Add the following dependency to your `pom.xml`:


  ```xml
  
    io.github.carsxe
    carsxe
    1.0.3
  
  ```


## Setup

Initialize the CarsXE object with your API key:


```java
import io.github.carsxe.CarsXE;
public class Main {
    public static void main(String[] args) {
        // Initialize the CarsXE object
        CarsXE carsxe = new CarsXE("YOUR_API_KEY_HERE");
    }
}
```


## Basic Usage

### VIN Specifications


```java
import io.github.carsxe.CarsXE;
import java.util.Map;
import java.util.HashMap;
public class Main {
    public static void main(String[] args) {
        CarsXE carsxe = new CarsXE("YOUR_API_KEY_HERE");
        Map params = new HashMap<>();
        params.put("vin", "WBAFR7C57CC811956");
        Map specs = carsxe.specs(params);
        System.out.println(specs);
    }
}
```


### International VIN Decoder


```java
Map params = new HashMap<>();
params.put("vin", "WF0MXXGBWM8R43240");
Map internationalVin = carsxe.internationalVinDecoder(params);
System.out.println(internationalVin);
```


### Market Value


```java
Map params = new HashMap<>();
params.put("vin", "WBAFR7C57CC811956");
Map marketValue = carsxe.marketvalue(params);
System.out.println(marketValue);
```


### Vehicle History


```java
Map params = new HashMap<>();
params.put("vin", "WBAFR7C57CC811956");
Map history = carsxe.history(params);
System.out.println(history);
```


### License Plate Decoder


```java
Map params = new HashMap<>();
params.put("plate", "7XER187");
params.put("state", "CA");
params.put("country", "US");
Map plateInfo = carsxe.platedecoder(params);
System.out.println(plateInfo);
```


### Vehicle Images


```java
Map params = new HashMap<>();
params.put("make", "BMW");
params.put("model", "X5");
params.put("year", "2019");
Map images = carsxe.images(params);
System.out.println(images);
```


### Vehicle Recalls


```java
Map params = new HashMap<>();
params.put("vin", "1C4JJXR64PW696340");
Map recalls = carsxe.recalls(params);
System.out.println(recalls);
```


### Plate Image Recognition


```java
String imageUrl = "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public";
Map plateRecognition = carsxe.plateImageRecognition(imageUrl);
System.out.println(plateRecognition);
```


### VIN OCR from Image


```java
String imageUrl = "https://user-images.githubusercontent.com/5663423/30922082-64edb4fa-a3a8-11e7-873e-3fbcdce8ea3a.png";
Map vinOcr = carsxe.vinOcr(imageUrl);
System.out.println(vinOcr);
```


### Year-Make-Model Search


```java
Map params = new HashMap<>();
params.put("year", "2023");
params.put("make", "Toyota");
params.put("model", "Camry");
Map ymm = carsxe.yearMakeModel(params);
System.out.println(ymm);
```


### OBD Code Decoder


```java
Map params = new HashMap<>();
params.put("code", "P0115");
Map obdCodes = carsxe.obdcodesdecoder(params);
System.out.println(obdCodes);
```


### Lien and Theft


```java
Map params = new HashMap<>();
params.put("vin", "2C3CDXFG1FH762860");
Map lienTheft = carsxe.LienAndTheft(params);
System.out.println(lienTheft);
```


Start building powerful automotive applications with CarsXE's Java SDK!


---

# MCP Quickstart Guide

> Get started with CarsXE's MCP server for AI-powered vehicle data integration in Claude, Cursor, VS Code, and other MCP-compatible tools.

Source: https://carsxe.com/docs/integrations/mcp-quickstart


## Available on Marketplaces

The CarsXE MCP server is listed on all major MCP marketplaces and registries:

| Marketplace | Link |
| ----------- | ---- |
| **MCP.so** | [View on MCP.so](https://mcp.so/server/carsxe/carsxe) |
| **MCP Market** | [View on MCP Market](https://mcpmarket.com/server/carsxe) |
| **Glama.ai** | [View on Glama.ai](https://glama.ai/mcp/servers/carsxe/cars-xe) |
| **MCP Registry** | [View on MCP Registry](https://registry.modelcontextprotocol.io/?q=carsxe) |
| **MCP Servers** | [View on MCP Servers](https://mcpservers.org/servers/carsxe/carsxe-mcp-server) |

## What is MCP?

Model Context Protocol (MCP) is an open standard that allows AI applications to securely connect to external data sources and tools. The CarsXE MCP server provides direct access to our comprehensive automotive database.

## What is the CarsXE MCP Server?

The CarsXE MCP server is a **Node.js/TypeScript** application that exposes a suite of tools for querying comprehensive vehicle data from the CarsXE API. It is designed for seamless integration with LLMs (like Anthropic Claude, OpenAI GPT, etc.), chatbots, and developer tools, providing:

- **Clean, modular code** for each CarsXE endpoint
- **Consistent, Markdown-rich output** for chat/LLM environments
- **Robust error handling** and user-friendly messages
- **Easy extensibility** for new endpoints and features

## Why Use CarsXE with MCP?

Connecting CarsXE to your AI editor or chat client via MCP gives you a supercharged vehicle data experience — directly inside the tools you already use:

| Benefit                           | Description                                                                                 |
| --------------------------------- | ------------------------------------------------------------------------------------------- |
| **Ask in plain English**          | No need to know API endpoints or parameters — just describe what you want                   |
| **Context-aware answers**         | The AI combines live vehicle data with your question for tailored, actionable responses     |
| **No tab switching**              | Get VIN specs, history, recalls, and values without leaving your editor or chat             |
| **Chain requests effortlessly**   | Decode a plate → get full specs → check recalls → get market value, all in one conversation |
| **Always live data**              | Every query hits the CarsXE API in real time — no stale cache or outdated results           |
| **Works in your favorite editor** | Claude Desktop, Cursor, VS Code, Windsurf, and any MCP-compatible client                    |

## Features

- Provides structured, Markdown-ready results that LLMs and MCP clients can use to generate comprehensive, professional answers based on the API data and user query
- Query vehicle specs, history, images, recalls, market value, and more
- Decode license plates and VINs (including OCR from images)
- Decode OBD (On-Board Diagnostics) codes
- All endpoints return elegant, grouped, emoji-rich Markdown
- Modular code: types, API logic, and formatters are separated for maintainability
- Simple to run, test, and extend

## Prerequisites

- **CarsXE API key** ([get one here](https://carsxe.com/dashboard/developer))
- **Node.js 18+ and npm** — required by editors that launch the MCP server via `npx mcp-remote@latest` (Claude Desktop, Windsurf). [Download Node.js](https://nodejs.org/)
- **An MCP-compatible client or editor** — one of: [Claude Desktop](https://claude.ai/download), [Cursor](https://www.cursor.com/), [VS Code](https://code.visualstudio.com/) with the GitHub Copilot extension, [Windsurf](https://windsurf.com/), or any other MCP-compatible tool

## Installation by Editor

All editors use the same remote MCP endpoint. Replace `YOUR_API_KEY` with your actual CarsXE API key in every config below.

### Claude.ai (Web) — Custom Connector

Claude.ai supports connecting to the CarsXE MCP server directly — no API key to copy, no config file. Authentication happens through a standard OAuth sign-in with your CarsXE account.

#### 1. Add the Connector

- Open [claude.ai](https://claude.ai) and go to **Settings → Connectors**
- Click **Add custom connector**
- Enter the CarsXE MCP server URL:

```
https://mcp.carsxe.com/mcp
```

#### 2. Connect Your CarsXE Account

- Click **Connect** next to the CarsXE connector
- A CarsXE sign-in window opens — sign in with your CarsXE account and click **Authorize**
- Claude.ai receives a secure access token tied to your account; your API key never leaves CarsXE

> Requests made through the connector use your CarsXE subscription and count toward your plan's quota, exactly like direct API calls.

#### 3. Use It

- In any chat, Claude can now call CarsXE tools (e.g., get-vehicle-specs, get-market-value)
- Try: _"Decode VIN 1HGBH41JXMN109186 and give me its market value"_

### Claude Desktop

#### 1. Download and Install Claude Desktop

- Go to the official [Claude Desktop download page](https://claude.ai/download)
- Download the installer for your operating system (macOS, Windows, or Linux)
- Install Claude Desktop by following the on-screen instructions

#### 2. Configure Claude Desktop to Use the CarsXE MCP Server

**a. Open Claude Desktop Settings**

- Launch the Claude Desktop app
- Go to **Settings** click on CTRL + , (or CMD + , on Mac) to open settings
- In the Settings window, go to the **Developer** tab (you may need to scroll or expand advanced options)
- Click **Edit Config** (or **Open Config File**)

**b. Edit the Configuration File**

- This will open the `claude_desktop_config.json` file in your default text editor.
- Locate the `"mcpServers"` section. If it does not exist, add it as shown below.
- Add or update the following entry for CarsXE:


```json showLineNumbers
{
  "mcpServers": {
    "carsxe": {
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.carsxe.com/mcp",
        "--header",
        "X-API-Key: YOUR_API_KEY"
      ]
    }
  }
}
```


- Replace `YOUR_API_KEY` with your actual CarsXE API Key
- **Tip:** You can add multiple MCP servers under `"mcpServers"` if you use more than one.
- **Save** the configuration file and close your editor.

**c. Restart Claude Desktop**

- Close and reopen the Claude Desktop app to apply the new configuration.

  > It may take a short delay for the changes to take effect.

#### 3. Verify the CarsXE MCP Server is Available

- After restarting, open Claude Desktop.
- Go to the tools or plugins section (usually in the search bar or under a tools menu).
- You should see **carsxe** listed as an available MCP server/tool.
- Try running a CarsXE tool (e.g., get-vehicle-specs) to verify everything is working.
  > This will only work if your API key is associated with an active subscription.

### Cursor


  }
>
  Install CarsXE MCP for Cursor


The install dialog will open pre-filled with:

| Field      | Value                      |
| ---------- | -------------------------- |
| **Name**   | CarsXE                     |
| **Type**   | streamableHttp             |
| **URL**    | https://mcp.carsxe.com/mcp |
| **Header** | `X-API-Key: YOUR_API_KEY`  |

Replace `YOUR_API_KEY` with your actual [CarsXE API key](https://carsxe.com/dashboard/developer), then click **Install**.

### Visual Studio Code (GitHub Copilot)


  }
>
  Install CarsXE MCP for VS Code


After clicking install, you'll need to add your API key manually:

1. Open **Command Palette** (`Ctrl+Shift+P` / `Cmd+Shift+P`)
2. Run **MCP: List Servers**
3. Find **CarsXE** in the list and click on it
4. Click **Show Configuration**
5. Replace `YOUR_API_KEY` with your actual [CarsXE API key](https://carsxe.com/dashboard/developer):


```json showLineNumbers
{
  "mcpServers": {
    "CarsXE": {
      "type": "http",
      "url": "https://mcp.carsxe.com/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}
```


6. Save the file — VS Code will connect automatically.

> **Note:** Make sure you have the **GitHub Copilot** extension installed and agent mode enabled (`chat.agent.enabled` in VS Code settings).

### Windsurf

#### 1. Open MCP Configuration

- Go to **Windsurf Settings** → **MCP** (or press `Ctrl+,` and search for MCP)
- Click **"Edit Config"** to open `~/.codeium/windsurf/mcp_config.json`

#### 2. Add the CarsXE Server


```json showLineNumbers
{
  "mcpServers": {
    "carsxe": {
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.carsxe.com/mcp",
        "--header",
        "X-API-Key: YOUR_API_KEY"
      ]
    }
  }
}
```


#### 3. Restart Windsurf

### Claude CLI

The Claude CLI supports direct HTTP connections to MCP servers.

#### 1. Add the Server

**Using the Command Line:**


```bash
claude mcp add --transport http carsxe https://mcp.carsxe.com/mcp \
  --header "X-API-Key: YOUR_API_KEY"
```


**Manual Configuration:**

Edit `~/.claude.json`:


```json showLineNumbers
{
  "mcpServers": {
    "carsxe": {
      "type": "http",
      "url": "https://mcp.carsxe.com/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}
```


#### 2. Verify and Start

List configured servers:


```bash
claude mcp list
```


Start Claude CLI:


```bash
claude
```


### Gemini CLI

#### 1. Configure the Server

Edit: `~/.gemini/settings.json`


```json showLineNumbers
{
  "theme": "Default",
  "selectedAuthType": "oauth-personal",
  "mcpServers": {
    "carsxe": {
      "url": "https://mcp.carsxe.com/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}
```


Replace `YOUR_API_KEY` with your actual [CarsXE API key](https://carsxe.com/dashboard/developer).

#### 2. Start Gemini


```bash
gemini
```


The CarsXE MCP server will be available immediately.

### Kiro CLI

#### 1. Configure the Server

Ensure you have the [Kiro CLI tool installed](https://kiro.dev/cli/) on your machine.

Create or edit `~/.kiro/settings/mcp.json`:


```json showLineNumbers
{
  "mcpServers": {
    "carsxe": {
      "url": "https://mcp.carsxe.com/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      },
      "disabled": false
    }
  }
}
```


Replace `YOUR_API_KEY` with your actual [CarsXE API key](https://carsxe.com/dashboard/developer).

#### 2. Connect

1. Open your terminal and run:


```bash
kiro-cli
```


2. Activate MCP servers:


```bash
/mcp
```


3. The CarsXE server will be listed and ready to use

### Codex CLI

#### 1. Configure the Server

Ensure you have the [Codex CLI tool installed](https://developers.openai.com/codex/cli/) on your machine.

Edit `~/.codex/config.toml`:


```toml showLineNumbers
[mcp_servers.carsxe]
url = "https://mcp.carsxe.com/mcp"
http_headers = { "X-API-Key" = "YOUR_API_KEY" }
```


Replace `YOUR_API_KEY` with your actual [CarsXE API key](https://carsxe.com/dashboard/developer).

#### 2. Start Codex


```bash
codex
```


Then list MCP servers:


```bash
/mcp
```


The CarsXE server will be available in the list.

## Example Usage

Here are some example prompts you can try:

Can you decode this VIN: 1HGBH41JXMN109186 and tell me the market value?

What recalls exist for a 2020 Honda Civic with VIN SHHFK7H47LU419620?

Show me images of a 2019 Tesla Model 3

Decode this license plate: ABC123 from California

## Available Tools

For a full list of supported tools and their descriptions, visit the [CarsXE Products page](https://carsxe.com/all-products).

### Supported Regions

- **United States**: Full coverage for all tools
- **Canada**: VIN decoding and market values
- **International**: VIN decoding for major markets
- **Europe**: Limited VIN decoding support

## Troubleshooting

### Common Issues

**Authentication Error**

- Verify your API key is correct
- Ensure you have an active subscription with sufficient API credits
- Check that your API key has the necessary permissions

**Connection Issues**

- For clients that launch the MCP server via `npx` (e.g., Claude Desktop, Windsurf), confirm Node.js is installed and accessible; for VS Code/Cursor setups that connect directly to the HTTP endpoint, Node.js is only needed if your client uses `npx` to start a local server.
- Verify your internet connection
- Check that the MCP server URL is correct: `https://mcp.carsxe.com/mcp`

**Tool Not Found**

- Restart your MCP client
- Verify the configuration syntax
- Check the server logs for errors

### Getting Help

- **Documentation**: [Full API Documentation](https://carsxe.com/docs)
- **Support**: [Contact Support](https://carsxe.com/support)

Ready to revolutionize your AI-powered vehicle data workflows with CarsXE MCP server!


---

# n8n Quickstart Guide

> Connect CarsXE vehicle data APIs to your n8n workflows — decode VINs, look up license plates, check vehicle history, market values, recalls, and more using the official CarsXE node.

Source: https://carsxe.com/docs/integrations/n8n-quickstart


## What is the CarsXE Node for n8n?

The CarsXE node for n8n is an official community node that brings comprehensive vehicle data to your automation workflows. Decode VINs, look up license plates, fetch market values, run history reports, check recalls, and more — all without writing a single line of code.

**n8n Integration Page**: [n8n.io/integrations/carsxe](https://n8n.io/integrations/carsxe/)

**npm Package**: [n8n-nodes-carsxe](https://www.npmjs.com/package/n8n-nodes-carsxe)

## Prerequisites

Before you begin, ensure you have:

1. A running n8n instance (cloud or self-hosted)
2. A CarsXE API account — [Sign in or create an account here](https://carsxe.com/signin)
3. Your CarsXE API key

## Installation

### Via Community Nodes (Recommended)

1. In your n8n instance, go to **Settings** → **Community Nodes**
2. Click **Install a community node**
3. Enter `n8n-nodes-carsxe`
4. Click **Install**

### Via npm (Self-hosted)


```bash
# Global installation
npm install -g n8n-nodes-carsxe
# Then restart n8n
n8n start
```


### Via Docker


```bash
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -e N8N_COMMUNITY_PACKAGES=n8n-nodes-carsxe \
  -v n8n_data:/home/node/.n8n \
  n8nio/n8n
```


## Setup

### Step 1: Get Your API Key

1. Visit the [CarsXE API dashboard](https://carsxe.com/dashboard/developer)
2. Navigate to your API keys section
3. Copy your API key

### Step 2: Add CarsXE Credentials in n8n

1. In n8n, go to **Credentials** → **New**
2. Search for **CarsXE API**
3. Paste your API key and click **Save**

## Available Operations

### VIN Operations

| Operation | Description |
|-----------|-------------|
| Decode VIN | Full vehicle specifications from a 17-character VIN |
| Decode International VIN | Worldwide VIN support for non-US vehicles |
| Get History Report | Ownership records and accident history |
| Get Market Value | Current market valuation |
| Get Safety Recalls | Manufacturer recall information |

### License Plate Operations

| Operation | Description |
|-----------|-------------|
| Decode License Plate | Vehicle information from a plate number (US, CA, AU, UK, and more) |
| Recognize Plate From Image | OCR extraction of a plate number from a photo URL |

### Vehicle Data Operations

| Operation | Description |
|-----------|-------------|
| Get Images | Professional vehicle photos by make, model, and year |
| Query by Year/Make/Model | Search vehicle data without a VIN |

### Diagnostic Operations

| Operation | Description |
|-----------|-------------|
| Decode OBD Code | Interpret check engine and diagnostic trouble codes |
| Extract VIN From Image | OCR extraction of a VIN from a photo URL |

## Example Workflows

### VIN Decoder API

```
[Webhook] → [CarsXE: Decode VIN] → [HTTP Response]
```

Receive a VIN via webhook and instantly return full vehicle specifications to the caller.

### License Plate Scanner

```
[Webhook] → [CarsXE: Decode License Plate] → [Database]
```

Accept a plate number and country, look up the vehicle, and store the result in your database.

### Daily Recall Checker

```
[Schedule] → [CarsXE: Get Safety Recalls] → [Email / Slack]
```

Run a scheduled check against a list of VINs and notify your team of any newly issued recalls.

### Market Value Monitor

```
[Schedule] → [CarsXE: Get Market Value] → [Google Sheets / CRM]
```

Periodically pull updated market valuations for your inventory and sync them to a spreadsheet or CRM.

## Quick Example: Decode a VIN

Configure the **CarsXE** node with:

| Field | Value |
|-------|-------|
| Resource | VIN |
| Operation | Decode VIN |
| VIN | `WBAFR7C57CC811956` |

**Response:**


```json
{
  "success": true,
  "vin": "WBAFR7C57CC811956",
  "year": "2012",
  "make": "BMW",
  "model": "7 Series",
  "trim": "750i",
  "engine": "4.4L V8 Turbocharged"
}
```


## Quick Example: License Plate Lookup

Configure the **CarsXE** node with:

| Field | Value |
|-------|-------|
| Resource | License Plate |
| Operation | Decode License Plate |
| Plate | `7XER187` |
| Country | `US` |
| State *(Additional Options)* | `CA` |

**Response:**


```json
{
  "success": true,
  "plate": "7XER187",
  "state": "CA",
  "make": "BMW",
  "model": "750Li"
}
```


## Troubleshooting

### Common Issues

**"Request failed with status code 401"**

- Check your API key in **Credentials**
- Ensure your account has sufficient credits
- Generate a new key from the [CarsXE Dashboard](https://carsxe.com/dashboard/developer)

**"Invalid VIN format"**

- VINs must be exactly 17 characters
- Example: `WBAFR7C57CC811956`

**Node not appearing after installation**

- Refresh your browser
- Clear the n8n cache: `rm -rf ~/.n8n/cache`
- Restart your n8n instance

Ready to automate your vehicle data workflows with CarsXE and n8n!


---

# Node.js Quickstart Guide

> Get started with CarsXE's Node.js SDK to integrate comprehensive vehicle data into your JavaScript and TypeScript applications.

Source: https://carsxe.com/docs/integrations/nodejs-quickstart


The CarsXE Node.js SDK provides a simple and powerful way to integrate vehicle data into your JavaScript and TypeScript applications. This guide will help you get started quickly.

For more information, see the package on npm.

## Installation

Install the CarsXE Node.js package using npm or yarn:

`npm install carsxe-api`

or

`yarn add carsxe-api`

## Setup

First, import the CarsXE client and initialize it with your API key:


```javascript
const { CarsXE } = require("carsxe-api");
// Initialize the client
const carsxe = new CarsXE("YOUR_API_KEY_HERE");
```


For TypeScript:


```typescript
import { CarsXE } from "carsxe-api";
const carsxe = new CarsXE("YOUR_API_KEY_HERE");
```


## Basic Usage

### VIN Specifications


```javascript
const vin = 'WBAFR7C57CC811956';
carsxe
  .specs({ vin })
  .then((vehicle) => console.log(vehicle.input.vin))
  .catch((error) => console.error(error));
```


Or using async/await:


```javascript
async function decodeVIN() {
  try {
    const vehicle = await carsxe.specs({
      vin: 'WBAFR7C57CC811956'
    });
    console.log(vehicle.input.vin);
  } catch (error) {
    console.error("Error:", error);
  }
}
decodeVIN();
```


### International VIN Decoder


```javascript
async function decodeInternationalVIN() {
  try {
    const intVin = await carsxe.internationalVinDecoder({
      vin: 'WF0MXXGBWM8R43240'
    });
    console.log(intVin);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Market Value


```javascript
async function getMarketValue() {
  try {
    const value = await carsxe.marketvalue({
      vin: 'WBAFR7C57CC811956'
    });
    console.log(value);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Vehicle History


```javascript
async function getVehicleHistory() {
  try {
    const history = await carsxe.history({
      vin: 'WBAFR7C57CC811956'
    });
    console.log(history);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### License Plate Decoder


```javascript
async function decodePlate() {
  try {
    const plate = await carsxe.platedecoder({
      plate: '7XER187',
      state: 'CA',
      country: 'US'
    });
    console.log(plate);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Vehicle Images


```javascript
async function getVehicleImages() {
  try {
    const imgs = await carsxe.images({
      make: 'BMW',
      model: 'X5',
      year: '2019'
    });
    console.log(imgs);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Vehicle Recalls


```javascript
async function checkRecalls() {
  try {
    const recalls = await carsxe.recalls({
      vin: '1C4JJXR64PW696340'
    });
    console.log(recalls);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Plate Image Recognition


```javascript
async function recognizePlateFromImage() {
  try {
    const plateImg = await carsxe.plateImageRecognition({
      imageUrl: 'https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public'
    });
    console.log(plateImg);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### VIN OCR from Image


```javascript
async function extractVINFromImage() {
  try {
    const vinOcr = await carsxe.vinOcr({
      imageUrl: 'https://user-images.githubusercontent.com/5663423/30922082-64edb4fa-a3a8-11e7-873e-3fbcdce8ea3a.png'
    });
    console.log(vinOcr);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Year-Make-Model Search


```javascript
async function searchByYearMakeModel() {
  try {
    const ymm = await carsxe.yearMakeModel({
      year: '2023',
      make: 'Toyota',
      model: 'Camry'
    });
    console.log(ymm);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### OBD Code Decoder


```javascript
async function decodeOBDCode() {
  try {
    const obd = await carsxe.obdcodesdecoder({
      code: 'P0115'
    });
    console.log(obd);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


### Lien and Theft


```javascript
async function getLienAndTheft() {
  try {
    const lienTheft = await carsxe.lienAndTheft({
      vin: '2C3CDXFG1FH762860'
    });
    console.log(lienTheft);
  } catch (error) {
    console.error("Error:", error);
  }
}
```


Start building powerful automotive applications with CarsXE's Node.js SDK!


---

# OpenClaw Skill

> Access the full suite of CarsXE vehicle data APIs directly from OpenClaw — decode VINs, look up license plates, get market values, check history, recalls, liens, OBD codes, and more.

Source: https://carsxe.com/docs/integrations/openclaw-quickstart


## What is the CarsXE Skill for OpenClaw?

[OpenClaw](https://openclaw.ai) is an AI agent platform that extends a conversational AI into a capable assistant through a skill system. The CarsXE skill gives your OpenClaw agent comprehensive automotive data capabilities — decode VINs, look up license plates, get market values, check vehicle history, recalls, lien and theft records, OBD codes, and more, all without leaving your agent environment.

Skills are installed from [Clawhub](https://clawhub.ai), OpenClaw's official skill marketplace. The CarsXE skill is listed at [CarsXE](https://clawhub.ai/carsxe/carsxe).

## Installation

Install the CarsXE skill from Clawhub with a single command:


```bash
openclaw skills install carsxe
```


## Setup

### Set Your CarsXE API Key

After installation, configure the skill with your CarsXE API key:


```bash
openclaw config set skills.entries.carsxe.env.CARSXE_KEY "cxe_live_YOUR_KEY"
```


Then restart the OpenClaw gateway for the change to take effect.

Don't have an API key yet? Get one from the [CarsXE developer dashboard](https://carsxe.com/dashboard/developer).

### Verify the Key is Set

The skill reads your key from the `CARSXE_KEY` environment variable. If it is missing or empty, OpenClaw will display an error. Re-run the config command above with your actual key and restart the gateway.

## Usage Examples

The skill is auto-invoked based on context — just describe what you need naturally. OpenClaw selects the right endpoint and chains requests when required.

### Decode a VIN

What are the specs for VIN WBAFR7C57CC811956?

### Decode a License Plate

Decode California plate 7XER187.

### Get Market Value

What's my car worth? VIN WBAFR7C57CC811956, 45k miles, clean condition, California.

### Check Safety Recalls

Does VIN 1C4JJXR64PW696340 have any open safety recalls?

### Lien and Theft Check

Check liens and theft records for VIN WBAFR7C57CC811956.

### Vehicle History Report

Show me the full history report for VIN WBAFR7C57CC811956.

### Decode an International VIN

Decode this international VIN: WF0MXXGBWM8R43240.

### Year/Make/Model Lookup

Look up a 2020 Toyota Camry LE.

### OBD Code Diagnosis

My check engine light shows P0300 — what does that mean?

### VIN from a Photo

Extract the VIN from this photo: https://example.com/vin.jpg

### Plate from a Photo

Extract the plate number from this photo: https://example.com/plate.jpg

### Vehicle Images

Get vehicle images for a 2019 BMW X5.

## Chained Requests

The skill automatically chains multiple API calls when a query requires it. For example:

**"Is this plate stolen and does it have open recalls?"**

1. `GET /v2/platedecoder` — resolve the plate to a VIN
2. `GET /v1/lien-theft` + `GET /v1/recalls` — run both checks in parallel against the VIN

OpenClaw handles the chaining transparently and presents a combined result.

## Error Handling

| HTTP Status | Meaning | What Happens |
| ----------- | ------- | ------------ |
| `401` / `invalid key` | Bad or missing API key | OpenClaw prompts you to set the key via `openclaw config set` |
| `404` / `no results` | VIN or plate not found | You are informed and asked to double-check the input |
| `429` | Rate limit exceeded | The skill waits and retries automatically |
| `5xx` | Server error | Retried once; error is reported if it persists |

> The skill also checks the `error` field in JSON responses — CarsXE can return HTTP 200 with an error body, and these are caught and surfaced to you.

## Managing the Skill

### Update the Skill


```bash
openclaw skills update carsxe
```


### Disable Without Removing


```json
{
  "skills": {
    "carsxe": {
      "enabled": false
    }
  }
}
```


## Troubleshooting

**Authentication error / invalid key**

- Run `openclaw config set skills.entries.carsxe.env.CARSXE_KEY "cxe_live_YOUR_KEY"` with your actual key
- Restart the OpenClaw gateway after updating the key
- Ensure your CarsXE account has an active subscription

**Skill not found after install**

- Restart your OpenClaw session
- Verify installation with `openclaw skills list`
- Check that `carsxe` is listed as `enabled: true` in your `openclaw.json`

**Tool not being auto-invoked**

- Ensure the skill is enabled in `openclaw.json`
- Restart the gateway to reload the skill registry
- Describe your request more specifically if the skill is not triggering

### Getting Help

- **Clawhub listing**: [carsxe](https://clawhub.ai/carsxe/carsxe)
- **CarsXE documentation**: [Full API Documentation](https://carsxe.com/docs)
- **Support**: [Contact Support](https://carsxe.com/support)

Ready to power your OpenClaw agent with comprehensive vehicle data from CarsXE!


---

# PHP Quickstart Guide

> Get started with CarsXE's PHP SDK to integrate comprehensive vehicle data into your PHP applications.

Source: https://carsxe.com/docs/integrations/php-quickstart


The CarsXE PHP SDK provides a simple and powerful way to integrate vehicle data into your PHP applications. This guide will help you get started quickly.

For more information, see the package on Packagist.

## Installation

Install the CarsXE PHP package using Composer:

`composer require carsxe/carsxe`

## Setup

First, require the autoloader and initialize the CarsXE client:


```php


## Basic Usage

### VIN Specifications


```php
specs(['vin' => $vin]);
    echo $vehicle['input']['vin'];
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### International VIN Decoder


```php
intVinDecoder([
        'vin' => 'WF0MXXGBWM8R43240'
    ]);
    echo json_encode($intvin, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Market Value


```php
marketValue([
        'vin' => 'WBAFR7C57CC811956'
    ]);
    echo json_encode($marketvalue, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Vehicle History


```php
history([
        'vin' => 'WBAFR7C57CC811956'
    ]);
    echo json_encode($history, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### License Plate Decoder


```php
plateDecoder([
        'plate' => '7XER187',
        'state' => 'CA',
        'country' => 'US'
    ]);
    echo json_encode($decoded_plate, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Vehicle Images


```php
images([
        'make' => 'BMW',
        'model' => 'X5',
        'year' => '2019'
    ]);
    echo json_encode($images, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Vehicle Recalls


```php
recalls([
        'vin' => '1C4JJXR64PW696340'
    ]);
    echo json_encode($recalls, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Plate Image Recognition


```php
plateImageRecognition([
        'upload_url' => 'https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public'
    ]);
    echo json_encode($plateimg, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### VIN OCR from Image


```php
vinOcr([
        'upload_url' => 'https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public'
    ]);
    echo json_encode($vinocr, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Year-Make-Model Search


```php
yearMakeModel([
        'year' => '2012',
        'make' => 'BMW',
        'model' => '5 Series'
    ]);
    echo json_encode($yymm, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### OBD Code Decoder


```php
obdCodesDecoder([
        'code' => 'P0115'
    ]);
    echo json_encode($obdcode, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


### Lien and Theft


```php
lienAndTheft([
        'vin' => '2C3CDXFG1FH762860'
    ]);
    echo json_encode($lienAndTheft, JSON_PRETTY_PRINT);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```


Start building powerful automotive applications with CarsXE's PHP SDK!


---

# Python Quickstart Guide

> Get started with CarsXE's Python SDK to integrate comprehensive vehicle data into your Python applications.

Source: https://carsxe.com/docs/integrations/python-quickstart


The CarsXE Python SDK provides a simple and powerful way to integrate vehicle data into your Python applications. This guide will help you get started quickly.

For more information, see the package on PyPI.

## Installation

Install the CarsXE Python package using pip:

`pip install carsxe`

## Setup

First, import the CarsXE client and initialize it with your API key:


  ```python 
import asyncio
from carsxe_api import CarsXE 
# Initialize the client 
carsxe = CarsXE('YOUR_API_KEY_HERE') 
```

## Basic Usage

### VIN Specifications

```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
vin = 'WBAFR7C57CC811956'
try:
    vehicle = asyncio.run(carsxe.specs({"vin": vin}))
    print(vehicle["input"]["vin"])
except Exception as error:
    print(f"Error: {error}")
```


### International VIN Decoder


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    intvin = asyncio.run(carsxe.int_vin_decoder({"vin": "WF0MXXGBWM8R43240"}))
    print(intvin)
except Exception as error:
    print(f"Error: {error}")
```


### Market Value


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    marketvalue = asyncio.run(carsxe.market_value({"vin": "WBAFR7C57CC811956"}))
    print(marketvalue)
except Exception as error:
    print(f"Error: {error}")
```


### Vehicle History


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    history = asyncio.run(carsxe.history({"vin": "WBAFR7C57CC811956"}))
    print(history)
except Exception as error:
    print(f"Error: {error}")
```


### License Plate Decoder


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    decoded_plate = asyncio.run(carsxe.plate_decoder({"plate": "7XER187", "state": "CA", "country": "US"}))
    print(decoded_plate)
except Exception as error:
    print(f"Error: {error}")
```


### Vehicle Images


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    images = asyncio.run(carsxe.images({"make": "BMW", "model": "X5", "year": "2019"}))
    print(images)
except Exception as error:
    print(f"Error: {error}")
```


### Vehicle Recalls


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    recalls = asyncio.run(carsxe.recalls({"vin": "1C4JJXR64PW696340"}))
    print(recalls)
except Exception as error:
    print(f"Error: {error}")
```


### Plate Image Recognition


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    plateimg = asyncio.run(carsxe.plate_image_recognition({"upload_url": "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"}))
    print(plateimg)
except Exception as error:
    print(f"Error: {error}")
```


### VIN OCR from Image


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    vinocr = asyncio.run(carsxe.vin_ocr({"upload_url": "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"}))
    print(vinocr)
except Exception as error:
    print(f"Error: {error}")
```


### Year-Make-Model Search


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    yymm = asyncio.run(carsxe.year_make_model({"year": "2012", "make": "BMW", "model": "5 Series"}))
    print(yymm)
except Exception as error:
    print(f"Error: {error}")
```


### OBD Code Decoder


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    obdcode = asyncio.run(carsxe.obd_codes_decoder({"code": "P0115"}))
    print(obdcode)
except Exception as error:
    print(f"Error: {error}")
```


### Lien and Theft


```python
import asyncio
from carsxe_api import CarsXE
carsxe = CarsXE('YOUR_API_KEY')
try:
    lien_and_theft = asyncio.run(carsxe.lien_and_theft({"vin": "2C3CDXFG1FH762860"}))
    print(lien_and_theft)
except Exception as error:
    print(f"Error: {error}")
```


Start building powerful automotive applications with CarsXE's Python SDK!


---

# Ruby Quickstart Guide

> Get started with CarsXE's Ruby gem to integrate comprehensive vehicle data into your Ruby applications.

Source: https://carsxe.com/docs/integrations/ruby-quickstart


The CarsXE Ruby gem provides a simple and powerful way to integrate vehicle data into your Ruby applications. This guide will help you get started quickly.

For more information, see the gem on RubyGems.

## Installation

Install the CarsXE Ruby gem using gem or bundler:

`gem install carsxe`

Or add it to your Gemfile:


```ruby 
gem 'carsxe' 
```


Then run `bundle install`.

## Setup

First, require the CarsXE client and initialize it with your API key:


```ruby
require 'carsxe' # Initialize the client
API_KEY = 'YOUR_API_KEY_HERE'
carsxe = Carsxe::CarsXE.new(api_key: API_KEY)
```


## Basic Usage

### VIN Specifications


```ruby
vin = 'WBAFR7C57CC811956'
begin
  vehicle = carsxe.specs('vin' => vin)
  puts vehicle['input']['vin']
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### International VIN Decoder


```ruby
begin
  intvin = carsxe.int_vin_decoder('vin' => 'WF0MXXGBWM8R43240')
  puts intvin
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Market Value


```ruby
begin
  marketvalue = carsxe.market_value('vin' => 'WBAFR7C57CC811956')
  puts marketvalue
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Vehicle History


```ruby
begin
  history = carsxe.history('vin' => 'WBAFR7C57CC811956')
  puts history
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### License Plate Decoder


```ruby
begin
  decoded_plate = carsxe.plate_decoder('plate' => '7XER187', 'state' => 'CA', 'country' => 'US')
  puts decoded_plate
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Vehicle Images


```ruby
begin
  images = carsxe.images('make' => 'BMW', 'model' => 'X5', 'year' => '2019')
  puts images
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Vehicle Recalls


```ruby
begin
  recalls = carsxe.recalls('vin' => '1C4JJXR64PW696340')
  puts recalls
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Plate Image Recognition


```ruby
begin
  plateimg = carsxe.plate_image_recognition('upload_url' =>
  'https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public')
  puts plateimg
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### VIN OCR from Image


```ruby
begin
  vinocr = carsxe.vin_ocr('upload_url' => 'https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public')
  puts vinocr
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Year-Make-Model Search


```ruby
begin
  yymm = carsxe.year_make_model('year' => '2012', 'make' => 'BMW', 'model' => '5 Series')
  puts yymm
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### OBD Code Decoder


```ruby
begin
  obdcode = carsxe.obd_codes_decoder('code' => 'P0115')
  puts obdcode
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


### Lien and Theft


```ruby
begin
  lien_and_theft = carsxe.lien_and_theft('vin' => '2C3CDXFG1FH762860')
  puts lien_and_theft
rescue StandardError => error
  puts "Error: #{error.message}"
end
```


Start building powerful automotive applications with CarsXE's Ruby gem!


---

# Snowflake Quickstart Guide

> Access comprehensive vehicle data directly in Snowflake through CarsXE's powerful API. This Native App provides an intuitive Streamlit interface and SQL callable procedures for seamless integration into your data workflows.

Source: https://carsxe.com/docs/integrations/snowflake-quickstart


# CarsXE Vehicle Data for Snowflake

Get started with the [CarsXE Snowflake Native App](https://app.snowflake.com/marketplace/listing/GZ2FQZRTA1H/carsxe-vehicle-data-from-carsxe) for comprehensive vehicle data access directly in your Snowflake environment.

## Features

- **Vehicle Data Endpoints** including VIN decoding, plate lookup, market value, history, images, recalls, Lien And Theft checks, and more
- **Streamlit UI** with guided setup and interactive endpoint testing
- **SQL Interface** for direct procedure calls in your queries and workflows
- **Secure API Key Storage** encrypted within your Snowflake account
- **Auto-Navigation** through setup steps for quick onboarding

## Prerequisites

- A Snowflake account with Native App installation permissions
- A CarsXE account with an active API key ([Sign up here](https://carsxe.com/register))
- The app only requires outbound access to `api.carsxe.com` and does not access any other external domains.

## Installation

1. **Install from Snowflake Marketplace**
   - Search for "CarsXE"
   - Select the "Vehicle Data from CarsXE"
   - Click "Get" and follow the installation prompts

2. **Open the App**
   - Navigate to the installed app in your Snowflake account
   - The setup wizard will launch automatically

3. **Complete Setup (3 Simple Steps)**

   The app guides you through each step:

   **Step 1: Connect External Access**
   - Click "Connect CarsXE EAI ↗"
   - Select or create an External Access Integration for `api.carsxe.com`

   **Step 2: Add Your API Key**
   - Enter your CarsXE API key
   - Click "Validate API key" to verify and save
   - **Note:** The API key is now stored securely using a bind variable in the `CORE.CONFIG` table to prevent SQL identifier issues.

   **Step 3: Start Using the APIs**
   - You're ready! Select an endpoint and make your first call

## Using the Streamlit UI

1. **Choose an Endpoint** from the dropdown menu (e.g., "Specs (VIN specs)")
2. **Enter Required Fields** (marked clearly in the form)
3. **Add Optional Parameters** if needed (expand "Optional parameters" section)
4. **Click "Call endpoint"** to get results

## Using SQL Directly

You can call the app fully through SQL, without using the UI, via:


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  path   => '',
  method => '',
  params => ''
);
```


**Parameters:**

- `path` – API endpoint path (e.g., `"/specs"`, `/v2/platedecoder`, `/v2/marketvalue`). For a complete list of available endpoints and their versions, see the [CarsXE API Documentation](https://carsxe.com/docs)
- `method` – `"GET"` or `"POST"` (most endpoints use GET; some endpoints like plate recognition and VIN OCR use POST. Check the [API Documentation](https://carsxe.com/docs) for endpoint-specific method requirements)
- `params` – JSON string with endpoint-specific parameters (do not include `key`; the app injects it automatically)

### SQL Examples

> **Important:** Before using these SQL examples, you must complete the setup steps in the Streamlit UI app, including configuring the External Access Integration (EAI) and adding your API key. See the [Installation](#installation) section above for details.

#### Validating API Key


```sql 
-- Validate your CarsXE API key 
CALL CORE.VALIDATE_CARSXE_API_KEY('your_api_key_here'); 
```


#### Saving API Key


```sql 
-- Save CarsXE API key in the secure CORE.CONFIG table 
CALL CORE.SET_CARSXE_API_KEY('your_api_key_here'); 
```


> **Note:** The API key storage now uses a bind variable internally to avoid SQL compilation errors with identifiers.

#### Specs by VIN


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/specs',
  'GET',
  '{"vin":"WBAFR7C57CC811956"}'
);
```


#### Plate Decoder


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/v2/platedecoder',
  'GET',
  '{"plate":"7XER187","country":"US","state":"CA"}'
);
```


#### Market Value


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/v2/marketvalue',
  'GET',
  '{"vin":"WBAFR7C57CC811956"}'
);
```


#### Images


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/images',
  'GET',
  '{"make":"toyota","model":"tacoma","year":"2018", "color":"blue","format":"json"}'
);
```


#### Plate Image Recognition (image URL)


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/platerecognition',
  'POST',
  '{"upload_url":"https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"}'
);
```


#### VIN OCR (image URL)


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/v1/vinocr',
  'POST',
  '{"upload_url":"https://user-images.githubusercontent.com/5663423/30922082-64edb4fa-a3a8-11e7-873e-3fbcdce8ea3a.png"}'
);
```


#### Lien And Theft Check


```sql
CALL CORE.CALL_CARSXE_ENDPOINT(
  '/v1/lien-theft',
  'GET',
  '{"vin":"2C3CDXFG1FH762860"}'
);
```


Internally, each call automatically adds `key=` in the request to CarsXE.

## Security & Governance

- The API key is stored securely in the `CORE.CONFIG` table using a bind variable to prevent SQL injection and identifier issues.
- All external HTTP calls run through a Snowflake External Access Integration approved for the app, which follows Snowflake governance policies.
- The app does not store, cache, or log CarsXE API responses outside the execution context of the request; it simply returns them to the caller (UI or SQL).

## Limitations

- No built-in caching: each call goes directly to CarsXE, which means latency and rate limits depend on your CarsXE plan and network conditions.
- The app does not modify or normalize CarsXE responses; it returns them as received (wrapped in JSON where necessary).

## Support

- For API behavior, data quality, pricing, or rate limit issues, contact CarsXE support via their official channels.
- For issues specific to this Snowflake Native App (installation errors, procedure failures, UI errors), use the contact information provided on the Snowflake Marketplace listing.


---

# Swift Quickstart Guide

> Get started with CarsXE's Swift package to integrate comprehensive vehicle data into your iOS, macOS, and other Swift applications.

Source: https://carsxe.com/docs/integrations/swift-quickstart


The CarsXE Swift package provides a simple and powerful way to integrate vehicle data into your Swift applications across iOS, macOS, tvOS, and watchOS. This guide will help you get started quickly.

For more information, see the package on Swift Package Index.

## Installation

### Swift Package Manager

Add the CarsXE Swift Package to your project by adding this dependency to your `Package.swift`:


```swift
// Package.swift (example)
dependencies: [
    .package(url: "https://github.com/carsxe/carsxe-swift-package.git", branch: "main")
]
```


And include it in your target dependencies:


```swift
// Package.swift (targets example)
targets: [
    .executableTarget(
        name: "YourApp",
        dependencies: [
            .product(name: "carsxe", package: "carsxe-swift-package")
        ]
    )
]
```


### Xcode

In Xcode, go to **File → Add Packages...** and enter:
`https://github.com/carsxe/carsxe-swift-package.git`

## Setup

First, import the CarsXE package and initialize it with your API key:


```swift
import SwiftUI
import carsxe
struct ContentView: View {
    // Initialize the client
    let carsxe = CarsXE(apiKey: "YOUR_API_KEY_HERE")
    var body: some View {
        // Your UI code here
        Text("CarsXE Example")
    }
}
```


## Basic Usage

### VIN Specifications


```swift
import carsxe
class VehicleService {
    private let carsxe = CarsXE(apiKey: "YOUR_API_KEY_HERE")
    func decodeVIN() {
        let vin = "WBAFR7C57CC811956"
        do {
            let vehicle = try carsxe.specs(["vin": vin])
            if let input = vehicle["input"] as? [String: Any],
               let vinValue = input["vin"] as? String {
                print("VIN: \(vinValue)")
            }
        } catch {
            print("Error: \(error)")
        }
    }
}
```


### International VIN Decoder


```swift
func decodeInternationalVIN() {
    do {
        let intvin = try carsxe.intVinDecoder(["vin": "WF0MXXGBWM8R43240"])
        print(intvin)
    } catch {
        print("Error: \(error)")
    }
}
```


### Market Value


```swift
func getMarketValue() {
    do {
        let marketvalue = try carsxe.marketValue(["vin": "WBAFR7C57CC811956"])
        print(marketvalue)
    } catch {
        print("Error: \(error)")
    }
}
```


### Vehicle History


```swift
func getVehicleHistory() {
    do {
        let history = try carsxe.history(["vin": "WBAFR7C57CC811956"])
        print(history)
    } catch {
        print("Error: \(error)")
    }
}
```


### License Plate Decoder


```swift
func decodePlate() {
    do {
        let decodedPlate = try carsxe.plateDecoder([
            "plate": "7XER187",
            "state": "CA",
            "country": "US"
        ])
        print(decodedPlate)
    } catch {
        print("Error: \(error)")
    }
}
```


### Vehicle Images


```swift
func getVehicleImages() {
    do {
        let images = try carsxe.images([
            "make": "BMW",
            "model": "X5",
            "year": "2019"
        ])
        print(images)
    } catch {
        print("Error: \(error)")
    }
}
```


### Vehicle Recalls


```swift
func getRecalls() {
    do {
        let recalls = try carsxe.recalls(["vin": "1C4JJXR64PW696340"])
        print(recalls)
    } catch {
        print("Error: \(error)")
    }
}
```


### Plate Image Recognition


```swift
func recognizePlateFromImage() {
    do {
        let plateResult = try carsxe.plateImageRecognition(
            imageUrl: "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"
        )
        print(plateResult)
    } catch {
        print("Plate image error: \(error)")
    }
}
```


### VIN OCR from Image


```swift
func extractVINFromImage() {
    do {
        let vinocr = try carsxe.vinOCR(
            imageUrl: "https://imagedelivery.net/moyiiSImjJPI_EZVxNMBBw/f49aed53-d736-4370-f3f4-97418841c800/public"
        )
        print(vinocr)
    } catch {
        print("VIN OCR error: \(error)")
    }
}
```


### Year-Make-Model Search


```swift
func searchByYearMakeModel() {
    do {
        let yymm = try carsxe.yearMakeModel([
            "year": "2012",
            "make": "BMW",
            "model": "5 Series"
        ])
        print(yymm)
    } catch {
        print("Error: \(error)")
    }
}
```


### OBD Code Decoder


```swift
func decodeOBDCode() {
    do {
        let obdcode = try carsxe.obdCodesDecoder(["code": "P0115"])
        print(obdcode)
    } catch {
        print("Error: \(error)")
    }
}
```


### Lien and Theft


```swift
func getLienAndTheft() {
    do {
        let lienTheft = try carsxe.lienAndTheft(["vin": "2C3CDXFG1FH762860"])
        print(lienTheft)
    } catch {
        print("Error: \(error)")
    }
}
```


Start building powerful automotive applications with CarsXE's Swift package!


---

# Latency & Regions

> Lower request latency from Europe with the EU endpoint, plus connection-reuse and caching tips that apply globally.

Source: https://carsxe.com/docs/latency-and-regions


The CarsXE API is hosted in the United States (Iowa, `us-central1`). For
customers based in the US this is already low-latency. For customers in
Europe, every request would otherwise pay a transatlantic round-trip on top of
the actual processing time — typically 80–150 ms before the request even
reaches our servers.

This page describes how to keep that overhead off your hot path.

## Use the EU endpoint from Europe

Internationally relevant endpoints — the photo-based recognition APIs, the
multi-country plate decoder, and the international VIN decoder — are also
available in `europe-west1` (Belgium). There are two equivalent ways to reach
the EU deployment; pick whichever is easier to configure in your client.

## eu-api.carsxe.com (regional hostname)

Swap the hostname; keep the path identical to the US form. The EU hostname
terminates in GCP `europe-west1` and proxies straight to the EU function
deployment.



```bash
curl -G https://eu-api.carsxe.com/v1/international-vin-decoder \
    -d key=CARSXE_API_KEY \
    -d vin=WF0MXXGBWM8R43240
```

```js
const { data } = await axios.get("https://eu-api.carsxe.com/v1/international-vin-decoder", {
  params: { key: apiKey, vin },
});
```

```python
import httpx

params = {
    "key": "CARSXE_API_KEY",
    "vin": "WF0MXXGBWM8R43240",
}

with httpx.Client(base_url="https://eu-api.carsxe.com", timeout=30.0) as client:
    response = client.get("/v1/international-vin-decoder", params=params)
    response.raise_for_status()
    data = response.json()
```

```php
 'https://eu-api.carsxe.com',
    'timeout' => 30,
]);

$response = $client->get('/v1/international-vin-decoder', [
    'query' => [
        'key' => 'CARSXE_API_KEY',
        'vin' => 'WF0MXXGBWM8R43240',
    ],
]);

$data = json_decode($response->getBody()->getContents(), true);
```

```ruby
require 'json'
require 'net/http'
require 'uri'

uri = URI('https://eu-api.carsxe.com/v1/international-vin-decoder')
uri.query = URI.encode_www_form(
  key: 'CARSXE_API_KEY',
  vin: 'WF0MXXGBWM8R43240'
)

response = Net::HTTP.get_response(uri)
data = JSON.parse(response.body)
```

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
)

func main() {
	params := url.Values{}
	params.Set("key", "CARSXE_API_KEY")
	params.Set("vin", "WF0MXXGBWM8R43240")

	endpoint := "https://eu-api.carsxe.com/v1/international-vin-decoder?" + params.Encode()
	resp, err := http.Get(endpoint)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var data map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		panic(err)
	}

	fmt.Println(data)
}
```

```java
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

String query = "key=" + URLEncoder.encode("CARSXE_API_KEY", StandardCharsets.UTF_8)
    + "&vin=" + URLEncoder.encode("WF0MXXGBWM8R43240", StandardCharsets.UTF_8);

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://eu-api.carsxe.com/v1/international-vin-decoder?" + query))
    .GET()
    .build();

HttpResponse response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());
```

```swift
import Foundation

var components = URLComponents(string: "https://eu-api.carsxe.com/v1/international-vin-decoder")!
components.queryItems = [
    URLQueryItem(name: "key", value: "CARSXE_API_KEY"),
    URLQueryItem(name: "vin", value: "WF0MXXGBWM8R43240"),
]

let (data, _) = try await URLSession.shared.data(from: components.url!)
let result = try JSONSerialization.jsonObject(with: data)
```

```csharp
using System.Net.Http.Json;

using HttpClient client = new()
{
    BaseAddress = new Uri("https://eu-api.carsxe.com")
};

var url = $"/v1/international-vin-decoder?key={Uri.EscapeDataString(\"CARSXE_API_KEY\")}&vin={Uri.EscapeDataString(\"WF0MXXGBWM8R43240\")}";
var data = await client.GetFromJsonAsync