OpenALPR CarCheck API

Name: OpenALPR CarCheck API
Brand: OpenALPR CarCheck API
Availability: InStock

★ Only Publicly Available OpenAPI DocumentAI/MLVisionapiKey4 EndpointsREST

For Agents

Recognize license plates and identify vehicle make, model, year, and color from an image URL, file upload, or raw bytes through 4 endpoints.

Use for: Recognize the license plate in this photo, Identify the make and model of a car from an image URL, Submit raw image bytes for plate recognition, List supported countries for plate recognition

Not supported: Does not handle facial recognition, driver identification, or VIN decoding - use for license plate text and vehicle make/model recognition only.

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.

Install Jentic One Beta

Connect the OpenALPR CarCheck API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the OpenALPR CarCheck API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fopenalpr.com%2Fopenalpr-carcheck-api" | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fopenalpr.com%2Fopenalpr-carcheck-api" | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with OpenALPR CarCheck API.

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

GET STARTED

Start building with OpenALPR CarCheck API

Explore with Jentic One

View OpenAPI Document

Use Cases

Patterns agents use OpenALPR CarCheck API for, with concrete tasks.

★ 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.

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.

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.

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.

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

4 endpoints — the openalpr carcheck api analyzes vehicle images and returns license plate text, vehicle make, model, year, body type, and color in json.

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

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

Why Jentic?

What agents get from Jentic-routed access to this vendor.

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 isolation

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.

Intent-based discovery

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

Alternatives and complements available in the Jentic catalogue.

Alternative

Plate Recognizer API

Cloud and on-premise license plate recognition with similar make/model output.

Choose Plate Recognizer when an air-gapped on-premise deployment is required or when MMR (make/model recognition) accuracy on European plates is the priority.

Complementary

OpenALPR CarCheck API (alt slug)

Sister entry of the same OpenALPR CarCheck spec under a different slug.

Use the openalpr-carcheck-api slug when the catalogue search prefers descriptive slugs over the generic 'main' identifier.

FAQs

Specific to using OpenALPR CarCheck API through Jentic.

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.