canonical: https://jentic.com/apis/openalpr.com/openalpr-carcheck-api # OpenALPR CarCheck API The OpenALPR CarCheck API analyzes vehicle images and returns license plate text, vehicle make, model, year, body type, and color in JSON. Images can be sent as multipart upload, raw bytes, or by remote URL, and results include per-character confidence scores plus bounding boxes for each detected plate. The service runs in the cloud so agents do not have to manage their own ALPR models. A secret key passed as a query parameter is required on every recognition call. ## For AI agents Recognize license plates and identify vehicle make, model, year, and color from an image URL, file upload, or raw bytes through 4 endpoints. ## Scope Does not handle facial recognition, driver identification, or VIN decoding - use for license plate text and vehicle make/model recognition only. ## Capabilities - Recognize a license plate from an uploaded image and return text plus per-region candidates - Send a remote image URL to /recognize_url and receive plate text, make, model, and color - Submit raw image bytes for the lowest-latency recognition path - Retrieve recognition configuration and supported countries via the /config endpoint - Read the bounding box and confidence score for each detected plate to filter low-quality matches - Identify vehicle attributes (body style, year range, color) alongside the plate read for fleet analytics - Filter recognition by country code so a US deployment ignores European plate formats ## Use cases ### Parking and Access Control Automate vehicle entry and exit logging at gated lots, garages, and corporate campuses by sending camera frames to OpenALPR CarCheck and matching the recognized plate against an allowlist. The API returns plate text plus a confidence score, so an agent can route low-confidence reads to manual review while opening the gate for high-confidence matches. Cloud processing removes the need to deploy on-premise GPUs at every site. Example prompt: POST an image of a car at the gate to /recognize_url, parse the top plate result, and verify confidence > 0.85 before triggering the gate-open webhook. ### Fleet Vehicle Identification Identify vehicles entering a facility by both plate and make/model so operations teams can reconcile arrivals against a fleet manifest. CarCheck returns vehicle attributes (make, model, year range, body style, color) alongside the plate read in a single response, removing the need for a separate make/model classifier. Useful for logistics yards, dealerships, and inspection stations. Example prompt: Submit a photo to POST /recognize and return both the plate string and the vehicle make/model/color fields for matching against the day's expected fleet manifest. ### Toll Road Plate Capture Power back-office plate review for tolling systems by sending edge-camera frames to CarCheck for confirmation. The bounding boxes returned with each recognition let an agent crop the plate region for human review when confidence is below threshold. Country filtering keeps recognition tuned to the operating region. Example prompt: POST raw image bytes to /recognize_bytes with country='us', then return the plate text, bounding box, and confidence so the toll system can decide whether to charge or escalate. ### AI Agent Plate Recognition Tool via Jentic Give an AI agent a plate recognition tool through Jentic so it can answer questions like 'what's the plate in this image' without integrating the API directly. The agent searches Jentic by intent, loads the schema for the relevant /recognize endpoint, and executes with the user-supplied secret_key kept in your Jentic One instance. Setup completes in under an hour. Example prompt: Use Jentic search 'recognize a license plate from an image', load the /recognize_url schema, and execute with image_url='https://example.com/car.jpg' and country='us'. ## Key endpoints | Method | Path | Description | | --- | --- | --- | | POST | `/recognize` | Recognize a plate from an uploaded image | | POST | `/recognize_bytes` | Recognize a plate from raw image bytes | | POST | `/recognize_url` | Recognize a plate from a remote image URL | | GET | `/config` | Retrieve supported countries and configuration | ## Key resources - **Recognize** — Submit a multipart image upload and get plate text, vehicle attributes, and confidence. - **RecognizeBytes** — Submit raw image bytes for the lowest-latency recognition path. - **RecognizeUrl** — Provide a publicly reachable image URL and have CarCheck fetch and analyze it. - **Config** — List supported countries and recognition options available to the calling key. ## Why Jentic - **Setup:** Wiring the OpenALPR CarCheck API by hand means attaching your API key on every request and handling the image upload, byte, and URL recognition paths yourself. Through Jentic you install once, import the OpenALPR CarCheck API from the API Directory, store the API key once, and your agent calls it. - **Permission scoping:** OpenALPR CarCheck takes the image in the request body rather than a resource id in the URL path, so limit the agent to the operations it needs, such as recognizing a plate from an uploaded image or a remote URL. You credit the agent only with the operations you allow. - **Credential handling:** Your OpenALPR API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context. - **Discovery method:** Agents search Jentic by intent such as 'read the license plate in this image', and Jentic returns the matching OpenALPR CarCheck operation with its input schema so the agent calls the right endpoint without browsing the reference docs. ## Related APIs - **Plate Recognizer API** — Cloud and on-premise license plate recognition with similar make/model output. - **OpenALPR CarCheck API (alt slug)** — Sister entry of the same OpenALPR CarCheck spec under a different slug. ## FAQ ### What authentication does the OpenALPR CarCheck API use? Each recognition call requires a secret_key passed as a query parameter. When called through Jentic the key is stored encrypted in the vault and injected at execution time so it never appears in agent prompts or logs. ### Can I recognize a plate from a remote image URL with OpenALPR CarCheck? Yes. POST to /recognize_url with the image_url parameter and CarCheck will fetch the image, run recognition, and return plate text plus vehicle make, model, year, and color in the JSON response. ### What are the rate limits for the OpenALPR CarCheck API? Rate limits are tied to the subscription plan attached to the secret_key rather than published in the spec. Free trial keys allow a small daily quota; paid plans scale to thousands of recognitions per minute. Check your plan dashboard for the exact ceiling. ### How do I run plate recognition on raw bytes through Jentic? Use the Jentic search query 'recognize a license plate from an image', select the /recognize_bytes operation, load its schema, and execute with the image bytes plus secret_key. Jentic streams the response back so the agent can read plate text and confidence directly. ### Does CarCheck return vehicle make and model along with the plate? Yes. Every successful response from /recognize, /recognize_bytes, and /recognize_url includes a vehicle block with make, model, year range, body type, and color in addition to the plate text and bounding box. ### How do I limit recognition to a specific country? Pass the country parameter (for example 'us', 'eu', 'gb') on any /recognize* call. The model then weights detection toward the plate format of that region, which improves accuracy and reduces false positives on non-matching plates. ### Can I limit what my agent is allowed to do with the OpenALPR CarCheck API? Yes. Because you run Jentic One yourself, your own rules decide which OpenALPR CarCheck operations and credentials the agent may use. You can grant it only the recognition endpoints it needs, such as recognizing a plate from an uploaded image (/recognize), a remote image URL (/recognize_url), or raw bytes (/recognize_bytes), and withhold the /config endpoint or any path you do not want it to reach. Since the image is passed in the request body rather than as a resource id in the URL, scoping is done at the operation level, and your stored API key is injected only for the calls you have allowed.